Go-bufio

Go
package main

import (
"bufio"
"fmt"
"os"
)

func main() {
// 打开文件（基础io.Reader）
file, err := os.Open("test.txt")
if err != nil {
fmt.Println("打开文件失败:", err)
return
}
defer file.Close()

// 创建缓冲读取器（默认缓冲区大小4096字节）
reader := bufio.NewReader(file)

// 也可以指定缓冲区大小：bufio.NewReaderSize(file, 8192)
}

方法

功能

适用场景

ReadByte()

读取1个字节

逐字节读取

ReadRune()

读取1个Unicode字符（处理多字节字符）

读取中文等多字节文本

ReadString(delim byte)

读取到指定分隔符（包含分隔符）

按自定义分隔符读取（如按逗号、换行符）

ReadLine()

读取一行（不包含换行符，低级别方法）

底层实现，一般用ReadString('\n')替代

ReadBytes(delim byte)

读取到指定分隔符，返回[]byte

二进制数据按分隔符读取

Peek(n int)

预览前n个字节（不移动读取指针）

提前判断数据格式

Read(p []byte)

读取数据到切片（兼容io.Reader）

批量读取

Go
package main

import (
"bufio"
"fmt"
"os"
)

func main() {
file, err := os.Open("test.txt")
if err != nil {
fmt.Println("打开文件失败:", err)
return
}
defer file.Close()

reader := bufio.NewReader(file)

// 循环读取每一行，直到EOF（文件结束）
for {
// 读取到换行符为止（包含换行符）
line, err := reader.ReadString('\n')
if err != nil {
// io.EOF是正常结束，其他是错误
if err.Error() == "EOF" {
// 处理最后一行（可能没有换行符）
if len(line) > 0 {
fmt.Print(line)
}
break
}
fmt.Println("读取失败:", err)
return
}
// 输出读取的行
fmt.Print(line)
}
}

Go
package main

import (
"bufio"
"fmt"
"os"
)

func main() {
// 打开文件（基础io.Writer，追加写入）
file, err := os.OpenFile("output.txt", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
fmt.Println("打开文件失败:", err)
return
}
defer file.Close()

// 创建缓冲写入器（默认4096字节缓冲区）
writer := bufio.NewWriter(file)

// 也可以指定缓冲区大小：bufio.NewWriterSize(file, 8192)
}

方法

功能

注意事项

Write(p []byte)

写入字节切片到缓冲区

不立即刷盘

WriteString(s string)

写入字符串到缓冲区

最常用，简化字符串写入

WriteByte(c byte)

写入单个字节

逐字节写入

WriteRune(r rune)

写入单个Unicode字符

处理多字节字符

Flush()

刷新缓冲区：将缓冲区数据写入底层Writer

必须调用！否则数据可能丢失

Available()

返回缓冲区剩余可用空间

判断是否需要手动Flush

Buffered()

返回缓冲区中未刷新的字节数

监控缓冲区状态

Go
package main

import (
"bufio"
"fmt"
"os"
)

func main() {
file, err := os.OpenFile("output.txt", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil {
fmt.Println("打开文件失败:", err)
return
}
defer file.Close()

writer := bufio.NewWriter(file)

// 写入数据到缓冲区（不立即刷盘）
data := []string{
"Hello, bufio!\n",
"Go语言缓冲I/O示例\n",
"缓冲区大小默认4096字节\n",
}

for _, s := range data {
// 写入字符串到缓冲区
_, err := writer.WriteString(s)
if err != nil {
fmt.Println("写入缓冲区失败:", err)
return
}
fmt.Printf("已写入缓冲区: %q (缓冲区未刷新字节数: %d)\n", s, writer.Buffered())
}

// 关键：刷新缓冲区，将数据写入文件
err = writer.Flush()
if err != nil {
fmt.Println("刷新缓冲区失败:", err)
return
}
fmt.Println("所有数据已写入文件")
}

Go
defer func() {
if err := writer.Flush(); err != nil {
fmt.Println("Flush失败:", err)
}
}()

Go
package main

import (
"bufio"
"fmt"
"os"
)

func main() {
file, err := os.Open("test.txt")
if err != nil {
fmt.Println("打开文件失败:", err)
return
}
defer file.Close()

// 创建Scanner
scanner := bufio.NewScanner(file)

// 循环扫描每一行（默认分割符是换行符）
lineNum := 1
for scanner.Scan() {
// 获取当前行内容
line := scanner.Text() // 返回string
// 也可以获取[]byte：scanner.Bytes()
fmt.Printf("第%d行: %s\n", lineNum, line)
lineNum++
}

// 检查扫描过程中是否出错
if err := scanner.Err(); err != nil {
fmt.Println("扫描失败:", err)
}
}

Go
package main

import (
"bufio"
"fmt"
"strings"
)

func main() {
// 从字符串创建Reader
data := "Hello Go bufio Scanner"
reader := strings.NewReader(data)
scanner := bufio.NewScanner(reader)

// 设置按单词分割
scanner.Split(bufio.ScanWords)

for scanner.Scan() {
fmt.Println("单词:", scanner.Text())
}

if err := scanner.Err(); err != nil {
fmt.Println("扫描失败:", err)
}
}

Go
package main

import (
"bufio"
"fmt"
"strings"
)

// 自定义分割函数：按逗号分割
func commaSplit(data []byte, atEOF bool) (advance int, token []byte, err error) {
// 查找逗号的位置
for i := 0; i < len(data); i++ {
if data[i] == ',' {
// 返回逗号前的内容，跳过逗号
return i + 1, data[:i], nil
}
}
// 如果到了EOF且有剩余数据，返回剩余部分
if atEOF && len(data) > 0 {
return len(data), data, nil
}
// 没有找到分隔符，需要更多数据
return 0, nil, nil
}

func main() {
data := "apple,banana,orange,grape"
reader := strings.NewReader(data)
scanner := bufio.NewScanner(reader)

// 设置自定义分割函数
scanner.Split(commaSplit)

for scanner.Scan() {
fmt.Println("水果:", scanner.Text())
}

if err := scanner.Err(); err != nil {
fmt.Println("扫描失败:", err)
}
}

维度

Read(p []byte)

Write(p []byte)

核心目的

从「数据源」（如文件、网络、内存）读取数据到用户提供的缓冲区p 中

将「用户提供的缓冲区p中的数据」写入到数据目标（如文件、网络、内存）中

数据流向

数据源 → 内存缓冲区p（外部→内部）

内存缓冲区p → 数据目标（内部→外部）

操作对象

读取「数据源」的内容，p是“接收容器”

写入「数据目标」的内容，p是“待发数据”

核心角色

你是“消费者”，从数据源拿数据

你是“生产者”，向目标送数据

Go
// Read：从数据源读数据到p
func (r Reader) Read(p []byte) (n int, err error)

// Write：把p中的数据写到目标
func (w Writer) Write(p []byte) (n int, err error)

维度

Read的p

Write的p

作用

用于「接收」从数据源读取的数据

用于「提供」要写入到目标的数据

数据状态

调用前：p是空白/旧数据（会被覆盖）；调用后：p[:n]是新读取的数据

调用前：p必须填充好要写入的数据；调用后：p内容不变（数据已被拷贝到目标）

容量要求

len(p)决定“最多能读取多少字节”（越大单次读取越多，但内存占用高）

len(p)决定“要写入的总字节数”（必须是已填充数据的长度）

维度

Read的n

Write的n

含义

实际从数据源读取到p中的字节数（0 ≤ n ≤ len(p)）

实际从p中写入到目标的字节数（0 ≤ n ≤ len(p)）

常见场景

n < len(p) 是正常的（如数据源只剩5字节，但p长度是10）

n < len(p) 是异常的（表示写入失败，需返回非nil错误，如io.ErrShortWrite）

特殊值

n=0 通常伴随err=io.EOF（数据源读完）

n=0 通常伴随非nil错误（如写入权限不足）

维度

Read的err

Write的err

正常结束

err=io.EOF（数据源读取完毕）

err=nil（全部写入成功）

部分成功

允许n>0且err=io.EOF（最后一次读取了部分数据，然后到末尾）

不允许n>0且err=nil（若n<len(p)，必须返回err）

常见错误

io.EOF、os.ErrNotExist（文件不存在）、网络断开

os.ErrPermission（权限不足）、磁盘满、网络断开

Go
buf := make([]byte, 10)
n, err := reader.Read(buf)
// n=3（实际读了3字节），err=nil（还没到EOF）
// 下次调用Read：n=0，err=io.EOF

Go
buf := []byte("0123456789")
n, err := writer.Write(buf)
// n=5（只写入了5字节），err=io.ErrShortWrite（写入不完整）

Go
// 读取文件全部内容（Read的典型用法）
func readFileContent(filePath string) ([]byte, error) {
file, err := os.Open(filePath)
if err != nil {
return nil, err
}
defer file.Close()

// 定义缓冲区（接收数据）
buf := make([]byte, 1024)
var result []byte

// 循环读取：直到EOF
for {
n, err := file.Read(buf) // 从文件（数据源）读数据到buf
if n > 0 {
// 把读取到的有效数据（buf[:n]）追加到结果
result = append(result, buf[:n]...)
}
if err == io.EOF {
return result, nil // 读取完成
}
if err != nil {
return nil, err // 其他错误
}
}
}

Go
// 写入全部数据到文件（Write的典型用法）
func writeFileContent(filePath string, data []byte) (int, error) {
file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
return 0, err
}
defer file.Close()

totalWritten := 0
// 循环写入：直到全部数据写入
for totalWritten < len(data) {
// 把data[totalWritten:]中的数据写入文件（目标）
n, err := file.Write(data[totalWritten:])
if err != nil {
return totalWritten, err // 写入失败，返回已写入的字节数
}
totalWritten += n
}
return totalWritten, nil // 全部写入成功
}

Go
type Reader struct {
// 底层的原始读取器（如os.File、net.Conn）
rd io.Reader
// 核心缓冲区：存储从底层Reader读取的字节数据
buf []byte
// r: 缓冲区中已读取的字节数（读指针，指向下一个可读取的位置）
// w: 缓冲区中已写入的字节数（写指针，指向下一个可写入的位置）
r, w int
// 错误状态（如EOF、读取错误）
err error
// 标记是否调用过ReadByte/UnreadByte等方法
lastByte int
lastRune int
}

Go
type Writer struct {
// 底层的原始写入器
wr io.Writer
// 核心缓冲区：存储待写入到底层Writer的字节数据
buf []byte
// n: 缓冲区中已写入的字节数（写指针）
n int
// 错误状态
err error
}

Go
// 简化版fill逻辑
func (b *Reader) fill() {
// 1. 如果缓冲区有未读数据，先压缩（把未读数据移到缓冲区开头）
if b.r > 0 {
copy(b.buf, b.buf[b.r:b.w])
b.w -= b.r
b.r = 0
}

// 2. 从底层Reader读取数据，填充到buf[b.w:]
n, err := b.rd.Read(b.buf[b.w:])
b.w += n
b.err = err
}

Go
// 简化版Flush逻辑
func (b *Writer) Flush() error {
if b.err != nil {
return b.err
}
// 缓冲区有数据才写入
if b.n == 0 {
return nil
}
// 批量写入到底层Writer
n, err := b.wr.Write(b.buf[0:b.n])
if n < b.n && err == nil {
err = io.ErrShortWrite
}
if err != nil {
// 写入失败，保留未写入的部分
if n > 0 && n < b.n {
copy(b.buf[0:b.n-n], b.buf[n:b.n])
}
b.n -= n
b.err = err
return err
}
// 清空缓冲区
b.n = 0
return nil
}

Go
type Scanner struct {
// 底层的缓冲读取器
r *Reader
// 分割函数（如按行、按单词）
split SplitFunc
// 缓存当前分割出的token（如一行数据）
buf []byte
// 错误状态
err error
}

Go
// Reader 定义了从数据源读取字节的基本方法
type Reader interface {
// Read 将数据读取到字节切片 p 中，返回两个值：
// n: 实际读取的字节数（0 ≤ n ≤ len(p)）
// err: 错误信息（如EOF表示读取到末尾，nil表示成功）
Read(p []byte) (n int, err error)
}

Go
package main

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

func main() {
// strings.Reader 是io.Reader的一个实现（从字符串读取）
reader := strings.NewReader("Hello, io package!")

// 定义缓冲区，每次读取8字节
buf := make([]byte, 8)

for {
n, err := reader.Read(buf)
fmt.Printf("读取到 %d 字节: %s\n", n, buf[:n])
if err != nil {
if err == io.EOF {
fmt.Println("读取到末尾")
break
}
fmt.Println("读取错误:", err)
return
}
}
}

Plain Text
读取到 8 字节: Hello, i
读取到 7 字节: o package!
读取到 0 字节:
读取到末尾

Go
// Writer 定义了向数据目标写入字节的基本方法
type Writer interface {
// Write 将字节切片 p 中的数据写入到目标，返回两个值：
// n: 实际写入的字节数（0 ≤ n ≤ len(p)）
// err: 错误信息（nil表示成功）
Write(p []byte) (n int, err error)
}

Go
package main

import (
"fmt"
"io"
"os"
)

func main() {
// os.Stdout 是io.Writer的实现（标准输出）
writer := os.Stdout

data := []byte("Hello, io.Writer!\n")
n, err := writer.Write(data)
if err != nil {
fmt.Println("写入错误:", err)
return
}
fmt.Printf("成功写入 %d 字节\n", n)
}

Plain Text
Hello, io.Writer!
成功写入 16 字节

Go
// ReaderFrom 从r读取数据，直到EOF或出错
type ReaderFrom interface {
ReadFrom(r Reader) (n int64, err error)
}

// WriterTo 向w写入数据，直到EOF或出错
type WriterTo interface {
WriteTo(w Writer) (n int64, err error)
}

接口

核心方法

用途

io.ReaderAt

ReadAt(p []byte, off int64)

从指定偏移量读取数据（随机读取）

io.WriterAt

WriteAt(p []byte, off int64)

向指定偏移量写入数据（随机写入）

io.Seeker

Seek(offset int64, whence int)

调整读写指针位置（如文件的Seek）

io.Closer

Close() error

关闭I/O资源（如文件、网络连接）

Go
// ReadWriter = Reader + Writer
type ReadWriter interface {
Reader
Writer
}

// ReadCloser = Reader + Closer
type ReadCloser interface {
Reader
Closer
}

Go
// Copy 将数据从src（Reader）拷贝到dst（Writer），返回拷贝的字节数和错误
func Copy(dst Writer, src Reader) (written int64, err error)

Go
package main

import (
"fmt"
"io"
"os"
)

func main() {
// 打开源文件
srcFile, err := os.Open("source.txt")
if err != nil {
fmt.Println("打开源文件失败:", err)
return
}
defer srcFile.Close()

// 创建目标文件
dstFile, err := os.Create("dest.txt")
if err != nil {
fmt.Println("创建目标文件失败:", err)
return
}
defer dstFile.Close()

// 拷贝数据
written, err := io.Copy(dstFile, srcFile)
if err != nil {
fmt.Println("拷贝失败:", err)
return
}
fmt.Printf("成功拷贝 %d 字节\n", written)
}

Go
func CopyN(dst Writer, src Reader, n int64) (written int64, err error)

Go
written, err := io.CopyN(dstFile, srcFile, 100)

Go
// ReadAll 读取src中的所有数据，返回字节切片和错误（Go 1.16+）
func ReadAll(r Reader) ([]byte, error)

Go
data, err := io.ReadAll(srcFile)
if err != nil {
// 处理错误
}
fmt.Println("文件内容:", string(data))

Go
// WriteString 向w写入字符串s，避免手动转换为[]byte
func WriteString(w Writer, s string) (n int, err error)

Go
io.WriteString(os.Stdout, "Hello, WriteString!\n")

Go
// Pipe 创建一个同步的管道，PipeWriter写入的数据会被PipeReader读取
func Pipe() (*PipeReader, *PipeWriter)

Go
package main

import (
"fmt"
"io"
"time"
)

func main() {
r, w := io.Pipe()

// 协程1：写入数据
go func() {
defer w.Close()
io.WriteString(w, "Hello from pipe!\n")
time.Sleep(100 * time.Millisecond)
io.WriteString(w, "Second line\n")
}()

// 协程2：读取数据
data, err := io.ReadAll(r)
if err != nil {
fmt.Println("读取失败:", err)
return
}
fmt.Println("读取到的数据:\n", string(data))
}

Go
// 正确的读取逻辑：循环读取直到EOF
func readAllData(r io.Reader) ([]byte, error) {
var buf []byte
tmp := make([]byte, 1024)
for {
n, err := r.Read(tmp)
if n > 0 {
buf = append(buf, tmp[:n]...)
}
if err == io.EOF {
return buf, nil
}
if err != nil {
return nil, err
}
}
}

Go
// 正确的写入逻辑：循环写入直到全部写入
func writeAllData(w io.Writer, data []byte) (int, error) {
total := 0
for total < len(data) {
n, err := w.Write(data[total:])
if err != nil {
return total, err
}
total += n
}
return total, nil
}

Go
file, err := os.Open("test.txt")
if err != nil {
// 处理错误
}
defer file.Close() // 确保关闭