Go语言中实现对已读取缓冲数据的查找（Seek）功能

package main

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

func main() {
    // 模拟一个原始的 io.Reader，例如文件、网络连接或一个大的数据流。
    // 这里使用 strings.NewReader 来模拟一个包含大量数据的数据源。
    originalDataSource := "Hello, Go Seek World! This is some more data that follows the initial part."
    originalReader := strings.NewReader(originalDataSource)

    // 假设我们需要读取前20个字节，并可能需要多次处理。
    // 1. 将需要重复处理的数据读取到字节切片中。
    // 注意：这里我们只读取原始数据源的前20个字节。
    bufferSize := 20
    dataToProcess := make([]byte, bufferSize)
    n, err := io.ReadFull(originalReader, dataToProcess) // io.ReadFull 确保读取指定数量的字节
    if err != nil && err != io.EOF {
        fmt.Printf("Error reading initial data: %v\n", err)
        return
    }
    if n < bufferSize {
        // 如果原始数据不足 bufferSize，调整切片大小
        dataToProcess = dataToProcess[:n]
        fmt.Printf("Warning: Only read %d bytes from original source, expected %d.\n", n, bufferSize)
    }

    fmt.Printf("--- 原始数据读取阶段 ---\n")
    fmt.Printf("从原始读取器中读取了 %d 字节: \"%s\"\n", n, string(dataToProcess))
    fmt.Printf("原始读取器当前位置：已消费 %d 字节\n\n", n)


    // 2. 从字节切片创建 bytes.Reader。
    // bytes.Reader 实现了 io.Reader 和 io.Seeker 接口。
    seekableReader := bytes.NewReader(dataToProcess)

    fmt.Printf("--- 第一次处理：从 seekableReader 读取 ---\n")
    // 第一次处理：读取前5个字节
    firstPart := make([]byte, 5)
    _, err = seekableReader.Read(firstPart)
    if err != nil {
        fmt.Printf("Error reading first part: %v\n", err)
        return
    }
    fmt.Printf("第一次读取 (前5字节): \"%s\"\n", string(firstPart))
    fmt.Printf("seekableReader 当前位置：%d\n\n", seekableReader.Size() - int64(seekableReader.Len()))


    fmt.Printf("--- 重置 seekableReader 位置并第二次处理 ---\n")
    // 需要重新从头开始读取。
    // 使用 Seek 方法将读取位置重置到偏移量 0。
    offset, err := seekableReader.Seek(0, io.SeekStart)
    if err != nil {
        fmt.Printf("Error seeking: %v\n", err)
        return
    }
    fmt.Printf("seekableReader 位置已重置到偏移量: %d\n", offset)

    // 第二次处理：读取前10个字节
    secondPart := make([]byte, 10)
    _, err = seekableReader.Read(secondPart)
    if err != nil {
        fmt.Printf("Error reading second part: %v\n", err)
        return
    }
    fmt.Printf("第二次读取 (前10字节): \"%s\"\n", string(secondPart))
    fmt.Printf("seekableReader 当前位置：%d\n\n", seekableReader.Size() - int64(seekableReader.Len()))


    fmt.Printf("--- 继续从原始读取器读取剩余数据 ---\n")
    // originalReader 的读取位置不受 seekableReader 操作的影响，
    // 它会从之前停止的地方继续读取。
    remainingData, err := io.ReadAll(originalReader)
    if err != nil {
        fmt.Printf("Error reading remaining data from original reader: %v\n", err)
        return
    }
    fmt.Printf("原始读取器剩余数据: \"%s\"\n", string(remainingData))
}

--- 原始数据读取阶段 ---
从原始读取器中读取了 20 字节: "Hello, Go Seek World!"
原始读取器当前位置：已消费 20 字节

--- 第一次处理：从 seekableReader 读取 ---
第一次读取 (前5字节): "Hello"
seekableReader 当前位置：5

--- 重置 seekableReader 位置并第二次处理 ---
seekableReader 位置已重置到偏移量: 0
第二次读取 (前10字节): "Hello, Go "
seekableReader 当前位置：10

--- 继续从原始读取器读取剩余数据 ---
原始读取器剩余数据: " This is some more data that follows the initial part."