Go语言中io.Reader流数据跳过指定字节的高效策略

package main

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

// SkipNBytes 通用函数，用于从 io.Reader 中跳过指定数量的字节
func SkipNBytes(r io.Reader, count int64) (int64, error) {
    // io.CopyN 会从 r 读取 count 字节并写入 io.Discard
    // io.Discard 会丢弃所有写入的数据
    written, err := io.CopyN(io.Discard, r, count)
    if err != nil && err != io.EOF {
        return written, fmt.Errorf("failed to skip %d bytes: %w", count, err)
    }
    return written, nil
}

func main() {
    data := "Hello, this is a test string to demonstrate skipping bytes."
    reader := strings.NewReader(data)

    fmt.Println("Original string:", data)

    // 尝试跳过 7 个字节 ("Hello, ")
    skipped, err := SkipNBytes(reader, 7)
    if err != nil {
        fmt.Println("Error skipping bytes:", err)
        return
    }
    fmt.Printf("Skipped %d bytes.\n", skipped)

    // 读取剩余内容
    remaining, err := io.ReadAll(reader)
    if err != nil {
        fmt.Println("Error reading remaining bytes:", err)
        return
    }
    fmt.Println("Remaining string:", string(remaining)) // 输出: this is a test string to demonstrate skipping bytes.

    // 再次尝试跳过更多字节，即使流中没有那么多数据
    reader2 := strings.NewReader("short string")
    fmt.Println("\nTesting skipping more than available:")
    skipped2, err2 := SkipNBytes(reader2, 20)
    if err2 != nil && err2 != io.EOF { // io.EOF 是预期行为，表示已到达流末尾
        fmt.Println("Error skipping bytes:", err2)
    }
    fmt.Printf("Skipped %d bytes (requested 20).\n", skipped2) // 输出: Skipped 12 bytes (requested 20).
}

package main

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

// SkipNBytesOptimized 根据 io.Reader 的类型选择最优的跳过方式
func SkipNBytesOptimized(r io.Reader, count int64) (int64, error) {
    // 尝试将 io.Reader 转换为 io.Seeker
    if seeker, ok := r.(io.Seeker); ok {
        // 如果是 io.Seeker，则使用 Seek 方法进行跳过
        // io.SeekCurrent 表示相对于当前位置偏移
        newPos, err := seeker.Seek(count, io.SeekCurrent)
        if err != nil {
            return 0, fmt.Errorf("failed to seek %d bytes: %w", count, err)
        }
        // 返回实际跳过的字节数（当前位置 - 原始位置），
        // 但由于 SeekCurrent 是相对偏移，我们知道如果无错误，就是 count
        // 实际上，Seek 返回的是新的绝对位置
        // 这里简化为返回 count，因为 Seek 成功就代表跳过 count 字节
        return count, nil
    } else {
        // 如果不是 io.Seeker，回退到通用方法
        return io.CopyN(io.Discard, r, count)
    }
}

func main() {
    data := "This is a longer string for seeking demonstration."
    reader := strings.NewReader(data) // strings.Reader 实现了 io.Seeker

    fmt.Println("Original string:", data)

    // 使用优化后的函数跳过 10 个字节 ("This is a ")
    skipped, err := SkipNBytesOptimized(reader, 10)
    if err != nil {
        fmt.Println("Error skipping bytes:", err)
        return
    }
    fmt.Printf("Skipped %d bytes using optimized method.\n", skipped)

    // 读取剩余内容
    remaining, err := io.ReadAll(reader)
    if err != nil {
        fmt.Println("Error reading remaining bytes:", err)
        return
    }
    fmt.Println("Remaining string:", string(remaining)) // 输出: longer string for seeking demonstration.

    // 演示一个不实现 io.Seeker 的 Reader，例如管道
    pr, pw := io.Pipe()
    go func() {
        defer pw.Close()
        _, _ = pw.Write([]byte("Pipe content to skip."))
    }()

    fmt.Println("\nTesting with a non-Seeker (io.Pipe):")
    skippedPipe, errPipe := SkipNBytesOptimized(pr, 5) // 跳过 "Pipe "
    if errPipe != nil {
        fmt.Println("Error skipping bytes from pipe:", errPipe)
    } else {
        fmt.Printf("Skipped %d bytes from pipe.\n", skippedPipe)
        remainingPipe, _ := io.ReadAll(pr)
        fmt.Println("Remaining pipe content:", string(remainingPipe)) // 输出: content to skip.
    }
}