Go语言io.Reader包装器实现Rot13解码：正确处理数据流的顺序

package main

import (
    "io"
    "os"
    "strings"
)

// rot13Reader 结构体，持有一个底层的 io.Reader
type rot13Reader struct {
    r io.Reader
}

// cipher 函数实现Rot13转换逻辑
func cipher(in byte) (out byte) {
    out = in // 默认不改变
    // 处理大写字母 'A'-'Z'
    if in >= 'A' && in <= 'Z' {
        out = (in - 'A' + 13) % 26 + 'A'
    }
    // 处理小写字母 'a'-'z'
    if in >= 'a' && in <= 'z' {
        out = (in - 'a' + 13) % 26 + 'a'
    }
    return
}

// Read 方法是 rot13Reader 实现 io.Reader 接口的核心
func (reader rot13Reader) Read(p []byte) (n int, err error) {
    // 错误的操作顺序：先尝试对 p 进行加密，然后从底层 reader 读取数据
    // 此时 p 中的数据是未知的（可能是零值或旧数据）
    for index := range p {
        p[index] = cipher(p[index]) // 这一步是对 p 中现有（可能是无效的）数据进行加密
    }
    // 随后，从底层 reader 读取数据到 p，这会覆盖掉之前加密过的数据
    n, err = reader.r.Read(p)
    return
}

func main() {
    s := strings.NewReader(
        "Lbh penpxrq gur pbqr!\n") // 这是一段经过Rot13加密的文本
    r := rot13Reader{s}
    io.Copy(os.Stdout, &r) // 将 Rot13 解码后的内容复制到标准输出
}

package main

import (
    "io"
    "os"
    "strings"
)

// rot13Reader 结构体，持有一个底层的 io.Reader
type rot13Reader struct {
    r io.Reader
}

// cipher 函数实现Rot13转换逻辑
func cipher(in byte) (out byte) {
    out = in // 默认不改变
    // 处理大写字母 'A'-'Z'
    if in >= 'A' && in <= 'Z' {
        out = (in - 'A' + 13) % 26 + 'A'
    }
    // 处理小写字母 'a'-'z'
    if in >= 'a' && in <= 'z' {
        out = (in - 'a' + 13) % 26 + 'a'
    }
    return
}

// Read 方法的正确实现：先读取，后转换
func (reader rot13Reader) Read(p []byte) (n int, err error) {
    // 第一步：从底层的 reader 读取数据到 p
    // n 是实际读取到的字节数，err 是读取过程中可能发生的错误
    n, err = reader.r.Read(p)

    // 第二步：只对实际读取到的 n 个字节进行 Rot13 转换
    // 确保只处理有效数据，避免操作 p 中未填充的部分
    for i := 0; i < n; i++ {
        p[i] = cipher(p[i])
    }

    // 第三步：返回实际读取和转换的字节数以及任何错误
    return n, err
}

func main() {
    s := strings.NewReader(
        "Lbh penpxrq gur pbqr!\n") // 这是一段经过Rot13加密的文本
    r := rot13Reader{s}