Go bytes.Lines 怎样按行读取字节序列

如果手里已经有一段 []byte，又希望按行处理而不先构造一个完整的二维切片，Go 1.24 提供的 bytes.Lines 很合适。它返回一个单次使用的 iter.Seq[[]byte]：带换行的行会保留换行符，输入末尾没有换行时，最后一段内容仍然会作为一行返回。

最小写法如下，核心就是对 bytes.Lines(data) 使用 range。注意它处理的是已经在内存中的字节序列；如果数据还在文件或网络流里，应在文末的方案边界中选择流式读取。

先把 bytes.Lines 的输出语义看清楚

bytes.Lines 的输入是 []byte，输出是 iter.Seq[[]byte]。每个元素对应一行，行尾的 \n 不会被自动删除；如果文本使用 CRLF，返回的字节行通常还会包含 \r\n。空输入不会产出空行，最后没有换行符的残余字节会被产出。

这个语义和“先按分隔符切开再处理”不完全一样。保留换行符对日志分片、协议文本和需要原样拼接的场景有用；如果业务只关心正文，就在自己的处理函数里显式去掉行尾分隔符。

用 range 遍历每一行

下面的函数把每行转换成字符串并收集到结果中。示例特意保留了原始的行边界，便于观察最后一行没有 \n 时仍然能够被处理。

package main

import (
    "bytes"
    "fmt"
)

func printLines(data []byte) {
    // bytes.Lines 返回单次迭代器，range 会依次取得每个字节行。
    for line := range bytes.Lines(data) {
        // %q 显示换行符，便于确认行尾是否仍在切片中。
        fmt.Printf("%q\n", line)
    }
}

func main() {
    // 最后一行没有换行符，用来观察末尾残行语义。
    printLines([]byte("alpha\nbeta\ngamma"))
}

这里没有先创建 [][]byte 作为全部行的集合。每次循环拿到的是当前行的字节切片，适合边遍历边解析、过滤或统计。若要跨过这次循环保存结果，应该根据生命周期要求复制，而不是默认保存切片视图。

处理 LF 和 CRLF 时只去掉分隔符

很多业务函数需要的是“不带行尾换行”的正文。可以先去掉 \n，再去掉可能存在的 \r。这样不会误删正文两端的普通空格，也不会把一行内部的内容当成分隔符。

package main

import "bytes"

func trimLineEnding(line []byte) []byte {
    // 先删除 LF，再兼容 CRLF 中剩下的 CR；TrimSuffix 不会复制正文。
    line = bytes.TrimSuffix(line, []byte("\n"))
    line = bytes.TrimSuffix(line, []byte("\r"))
    return line
}

func nonEmptyLines(data []byte) [][]byte {
    var result [][]byte
    for line := range bytes.Lines(data) {
        // 只跳过空行，保留正文中的空格和其他字节。
        line = trimLineEnding(line)
        if len(line) == 0 {
            continue
        }
        // 若 result 要在循环结束后继续使用，这里复制一份独立数据。
        result = append(result, bytes.Clone(line))
    }
    return result
}

如果结果只在当前循环体内立即消费，可以不复制；如果结果会被异步任务、缓存或长期对象保存，bytes.Clone 能把它与原始输入的生命周期分开。这里的复制是生命周期决策，不是 bytes.Lines 自动要求的固定步骤。

单次迭代器和切片生命周期要分开判断

bytes.Lines 返回的迭代器是单次使用的。不要把它存进变量后，先完整遍历一次，再期待第二次遍历仍然得到相同内容；如果需要多次处理，应重新从原始 []byte 创建迭代器，或者把业务需要的结果明确收集下来。

package main

import "bytes"

func countAndCollect(data []byte) (int, [][]byte) {
    count := 0
    var saved [][]byte

    // 一个 range 同时完成统计和保存，避免重复消费单次迭代器。
    for line := range bytes.Lines(data) {
        count++
        // 保存到函数返回值前复制，避免长期持有输入的大底层数组。
        saved = append(saved, bytes.Clone(line))
    }
    return count, saved
}

这里有两个独立判断：一是迭代器只能按当前遍历消费；二是行切片可能只是原始输入的视图。只要保存时间超过当前处理阶段，或者原始输入来自一个需要释放的大缓冲区，就要认真评估是否复制。

按输入形态选择 bytes.Lines、bytes.Split 还是 bufio

性能判断不能只看函数名。bytes.Lines 的优势前提是输入已经是内存中的 []byte，并且业务可以边遍历边处理；它不负责把文件或网络连接变成流式读取。若需要一次性拿到所有行，bytes.Split 更直观；若输入还在 io.Reader 中，应该考虑 bufio.Scanner 或 bufio.Reader。

如果要记录自己的基线，可以围绕三项指标设计 benchmark：输入是否已经在内存、是否需要保存所有行、每行是否会复制。不要把某一次本机测得的数字当成所有数据规模下的结论；真正影响结果的往往是输入大小、最长行、保存策略和后续解析成本。

package linebench

import (
    "bytes"
    "testing"
)

func BenchmarkLineStrategies(b *testing.B) {
    data := []byte("alpha\nbeta\ngamma\n")
    b.ReportAllocs()
    for i := 0; i 

这个 benchmark 片段只是测量入口，不能替代真实业务数据。若实际代码需要把每一行转成字符串、解析 JSON 或复制到队列，就应把同样的后续动作放入测量范围。

几个容易混淆的边界

• 空输入不是一行空字符串。空的 []byte 不会让迭代器产出一项。
• 末尾残行仍然有效。文本没有以 \n 结束时，最后的非空字节仍会被返回。
• 行尾默认保留。需要纯正文时显式处理 LF 和 CRLF，不要靠字符串打印结果猜测。
• 输入必须先在内存中。面对超大文件或长连接，优先使用 Reader 方案，避免为了调用 bytes.Lines 先整体读入。
• 保存就要考虑复制。短暂使用可以保留视图，跨异步边界或长期缓存则应建立独立副本。

总结

bytes.Lines 适合“已有 []byte、需要按行遍历、可以边处理边消费”的任务。记住三个关键点：它返回单次迭代器；每行保留换行符；没有末尾换行的残余内容也会出现。输入来自流时不要为了追求新 API 而强行整体读入，先根据内存边界和行数据生命周期选择合适的读取方案。

相关问题

bytes.Lines 会自动删除行尾换行符吗？

不会。带换行的行会保留终止换行符；需要正文时应在业务代码中显式去掉 LF，并按需处理 CRLF。

bytes.Lines 能直接读取文件流吗？

不能。它接收 []byte，文件或网络流应使用 bufio.Scanner、bufio.Reader 等 Reader 方案。

为什么保存 bytes.Lines 返回的行时还要 Clone？

返回的行是输入字节序列上的切片视图。只在当前循环中使用通常不必复制；跨越异步任务、缓存或原始缓冲区释放边界时，复制能让保存的数据拥有独立生命周期。

参考资料：https://pkg.go.dev/bytes#Lines、https://pkg.go.dev/iter、https://go.dev/src/bytes/example_test.go