Go语言：实现多字节分隔符的流式读取

package main

import (
    "bytes"
    "fmt"
    "io" // 导入io包以使用io.EOF
    "log"
)

// reader 接口定义，要求实现ReadString方法。
// bufio.Reader 和 bytes.Buffer 都满足此接口。
type reader interface {
    ReadString(delim byte) (line string, err error)
}

// read 函数从 r 中读取数据，直到遇到完整的 delim 字节序列。
// 返回 delim 之前的数据。
func read(r reader, delim []byte) (line []byte, err error) {
    // 确保分隔符不为空，否则可能导致无限循环或错误行为
    if len(delim) == 0 {
        return nil, fmt.Errorf("delimiter cannot be empty")
    }

    // 循环读取直到找到完整的 delim
    for {
        // 使用分隔符的最后一个字节作为 ReadString 的单字节分隔符
        // 这样做可以利用 ReadString 的内部优化，减少不必要的循环和切片操作
        s, readErr := r.ReadString(delim[len(delim)-1])
        if readErr != nil && readErr != io.EOF {
            // 遇到非EOF错误，直接返回
            return nil, readErr
        }

        // 将读取到的字符串转换为字节切片并追加到累积的 line 缓冲区
        line = append(line, []byte(s)...)

        // 检查当前累积的 line 是否以完整的 delim 结束
        if bytes.HasSuffix(line, delim) {
            // 如果是，则返回 delim 之前的数据
            return line[:len(line)-len(delim)], nil
        }

        // 如果 ReadString 返回了 EOF，且当前 line 缓冲区不以 delim 结束，
        // 则说明在文件/流结束前没有找到完整的 delim。
        // 此时，根据需求可以选择返回已读取的所有数据，或者返回错误。
        // 这里选择返回错误，表示未找到完整的 delim。
        if readErr == io.EOF {
            // 如果在EOF时，line缓冲区中包含数据但没有完整的delim，
            // 则认为未能成功找到分隔符，返回io.EOF。
            // 如果需要返回部分数据，可以修改此逻辑。
            return nil, io.EOF // 或者 return line, nil 视具体业务需求
        }
    }
}

func main() {
    // 示例数据源：一个 bytes.Buffer 模拟输入流
    // 注意数据中包含多个 "delim" 字符串
    src := bytes.NewBufferString("123deli456elim789delimABCdelimDEF")
    targetDelim := []byte("delim")

    fmt.Printf("从流中读取，分隔符为 %q:\n", targetDelim)

    for {
        // 调用自定义的 read 函数
        b, err := read(src, targetDelim)
        if err != nil {
            if err == io.EOF {
                // 正常结束，流中已无更多数据或未找到更多分隔符
                fmt.Println("流读取完毕或未找到更多分隔符。")
                break
            }
            log.Fatalf("读取错误: %v", err) // 遇到其他错误则致命退出
        }

        // 打印读取到的数据
        fmt.Printf("%q\n", b)
    }

    // 另一个示例：分隔符在末尾，或者流中没有分隔符
    fmt.Println("\n--- 另一个示例 ---")
    src2 := bytes.NewBufferString("Hello World! This is a test.")
    targetDelim2 := []byte("test.")
    b2, err2 := read(src2, targetDelim2)
    if err2 != nil {
        if err2 == io.EOF {
            fmt.Printf("未找到分隔符 %q，或流已结束。已读取数据: %q\n", targetDelim2, b2)
        } else {
            log.Fatalf("读取错误: %v", err2)
        }
    } else {
        fmt.Printf("读取到: %q\n", b2)
    }

    fmt.Println("\n--- 包含分隔符但未完全匹配的示例 ---")
    src3 := bytes.NewBufferString("prefix_del_suffix")
    targetDelim3 := []byte("_delim_")
    b3, err3 := read(src3, targetDelim3)
    if err3 != nil {
        if err3 == io.EOF {
            fmt.Printf("未找到分隔符 %q，或流已结束。已读取数据: %q\n", targetDelim3, b3)
        } else {
            log.Fatalf("读取错误: %v", err3)
        }
    } else {
        fmt.Printf("读取到: %q\n", b3)
    }
}

从流中读取，分隔符为 "delim":
"123deli456elim789"
"ABC"
流读取完毕或未找到更多分隔符。

--- 另一个示例 ---
读取到: "Hello World! This is a "

--- 包含分隔符但未完全匹配的示例 ---
未找到分隔符 "_delim_"，或流已结束。已读取数据: []