Golang中为什么会重复获取相同数据？

Golang中为什么会重复获取相同数据？ 我最近在我的一个工具中添加了ROT13逻辑。这个工具连接到服务器，我在客户端上运行命令。

以下是添加ROT13之前的代码： https://play.golang.org/p/DAE4cLq3RSx 一切运行正常。

以下是添加ROT13之后的代码。它们之间的差异已用下划线标出： https://play.golang.org/p/DfFJSvuBx05

这两个函数都处理命令的输出。

ROT13本身工作正常，但我多次得到相同的输出，而之前没有发生这种情况。事实上，如果我撤销更改，一切都能完美运行。

示例：

$ whoami
$ xnyv
$ whoami
$ xnyv
xnyv
$ whoami
$ xnyv
xnyv
xnyv
$ whoami
$ xnyv
xnyv
xnyv
xnyv

为什么我会得到这个结果？我该如何修复它？ 可能是 fub 的错吗？感觉像是输出以某种方式被缓存了，但我也可能错了。


更多关于Golang中为什么会重复获取相同数据？的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

对于遇到与我相同问题的人：有效的解决方案是使用 fub。我不得不在 for 循环后使用 fub.Reset() 来清空 fub。

更多关于Golang中为什么会重复获取相同数据？的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


问题出在 fub 上。 如果我将 fub 移到 for 循环内部，我能正确获得一次输出，但如果我运行像 cat /etc/passwd 这样的命令，工具就会报错并崩溃： panic: runtime error: index out of range [512] with length 512

在Golang中重复获取相同数据通常是由于缓冲区的读取和写入逻辑问题导致的。从你提供的代码对比来看，问题很可能出现在fub函数的实现上。在添加ROT13逻辑后，fub函数中的缓冲区处理可能没有正确清空或重置，导致重复读取之前的数据。

以下是一个示例代码，展示了可能导致重复数据问题的常见场景以及修复方法：

package main

import (
    "bytes"
    "io"
    "strings"
)

// 有问题的fub函数实现
func fubProblematic(r io.Reader, w io.Writer) error {
    buf := make([]byte, 1024)
    for {
        n, err := r.Read(buf)
        if err != nil && err != io.EOF {
            return err
        }
        if n == 0 {
            break
        }
        
        // ROT13转换
        for i := 0; i < n; i++ {
            buf[i] = rot13(buf[i])
        }
        
        // 这里可能重复写入相同的数据
        w.Write(buf[:n])
        w.Write(buf[:n]) // 错误：重复写入
    }
    return nil
}

// 修复后的fub函数
func fubFixed(r io.Reader, w io.Writer) error {
    buf := make([]byte, 1024)
    for {
        n, err := r.Read(buf)
        if err != nil && err != io.EOF {
            return err
        }
        if n == 0 {
            break
        }
        
        // 创建新的切片来处理转换后的数据
        transformed := make([]byte, n)
        for i := 0; i < n; i++ {
            transformed[i] = rot13(buf[i])
        }
        
        // 只写入转换后的数据一次
        w.Write(transformed)
    }
    return nil
}

func rot13(b byte) byte {
    switch {
    case b >= 'A' && b <= 'Z':
        return 'A' + (b-'A'+13)%26
    case b >= 'a' && b <= 'z':
        return 'a' + (b-'a'+13)%26
    }
    return b
}

func main() {
    input := strings.NewReader("whoami\n")
    var output bytes.Buffer
    
    // 测试有问题的版本
    fubProblematic(input, &output)
    println("Problematic output:", output.String())
    
    // 重置测试
    input = strings.NewReader("whoami\n")
    output.Reset()
    
    // 测试修复版本
    fubFixed(input, &output)
    println("Fixed output:", output.String())
}

关键问题分析：

  1. 缓冲区重用问题：在循环中重复使用同一个缓冲区时，如果没有正确处理读取边界，可能会读取到之前的数据残留。

  2. 写入逻辑错误：可能在ROT13转换后多次调用了写入操作，或者写入的字节数不正确。

  3. 读取位置问题：io.Reader的读取位置可能没有正确推进，导致重复读取相同数据。

修复建议：

// 确保每次读取都使用正确大小的切片
func fubCorrect(r io.Reader, w io.Writer) error {
    buf := make([]byte, 1024)
    for {
        n, err := r.Read(buf)
        if err != nil {
            if err == io.EOF {
                break
            }
            return err
        }
        
        // 只处理实际读取到的字节
        data := buf[:n]
        
        // 应用ROT13转换
        for i := range data {
            data[i] = rot13(data[i])
        }
        
        // 确保只写入一次
        if _, err := w.Write(data); err != nil {
            return err
        }
    }
    return nil
}

检查你的实际代码中是否存在以下问题：

  • 是否在循环中多次调用Write方法
  • 是否正确地处理了io.EOF错误
  • 是否在读取新数据前清空了缓冲区
  • 是否正确地计算了要处理的字节数

根据你描述的输出模式（重复次数逐渐增加），这很可能是由于每次迭代都累积写入之前所有数据的结果。

回到顶部