go语言之文件读取

Posted on In , Views:
Go 的 `os` 包和 `io` 包提供了丰富的功能来读取和写入文件

Go 语言文件读取详解与最佳实践

在 Go 语言中，文件操作是常见的任务之一。Go 的 os 包和 io 包提供了丰富的功能来读取和写入文件。本文将通过一个具体的代码示例，深入探讨 Go 语言中文件读取的几种常用方法，并总结一些工程中的最佳实践。

代码示例

首先，让我们来看一下你提供的示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package main

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

func check(e error) {
	if e != nil {
		fmt.Errorf("err : ", e)
	}
}

func main() {
	p := fmt.Println
	pf := fmt.Printf

	// 使用 os.ReadFile 一次性读取整个文件内容
	data, err := os.ReadFile("./tmp/dat")
	check(err)
	p(string(data))

	// 使用 os.Open 打开文件并进行更细粒度的读取
	f, err := os.Open("./tmp/dat")
	check(err)
	defer f.Close() // 确保文件在使用完毕后关闭

	// 从文件中读取指定数量的字节
	b1 := make([]byte, 5)
	n1, err := f.Read(b1)
	check(err)
	pf("%d bytes: %s\n", n1, string(b1[:n1]))

	// 使用 Seek 方法移动文件指针，并从新的位置读取
	o2, err := f.Seek(6, io.SeekStart)
	check(err)
	b2 := make([]byte, 6)
	n2, err := f.Read(b2)
	pf("%d bytes @ %d: ", n2, o2)
	pf("%v\n", string(b2[:n2]))

	_, err = f.Seek(2, io.SeekCurrent) // 相对于当前位置移动
	check(err)

	_, err = f.Seek(-4, io.SeekEnd) // 相对于文件末尾移动
	check(err)

	// 使用 io.ReadAtLeast 确保读取到指定的最少字节数
	o3, err := f.Seek(6, io.SeekStart)
	check(err)
	b3 := make([]byte, 6)
	n3, err := io.ReadAtLeast(f, b3, 6)
	check(err)
	pf("%d bytes @ %d: %s\n", n3, o3, string(b3))

	// 使用 bufio.NewReader 提高读取效率
	_, err = f.Seek(0, io.SeekStart)
	check(err)
	r4 := bufio.NewReader(f)
	b4, err := r4.Peek(5) // 预览 Reader 缓冲区的前 N 个字节
	check(err)
	fmt.Printf("5 bytes: %s\n", string(b4))
}

代码详解

  1. 导入包:

    1
    2
    3
    4
    5
    6
    import (
        "bufio"
        "fmt"
        "io"
        "os"
    )
    • os: 提供了操作系统相关的功能，包括文件操作。
    • fmt: 用于格式化输入输出。
    • io: 提供了基本的 I/O 接口。
    • bufio: 提供了带缓冲的 I/O 操作，可以提高读写效率。

  2. 错误检查函数 check:

    1
    2
    3
    4
    5
    func check(e error) {
        if e != nil {
            fmt.Errorf("err : ", e)
        }
    }

    这是一个简单的错误处理函数。在实际项目中，你可能需要更完善的错误处理机制，例如记录日志、返回错误等。

  3. os.ReadFile:

    1
    2
    3
    data, err := os.ReadFile("./tmp/dat")
    check(err)
    p(string(data))

    os.ReadFile 函数会一次性读取整个文件的内容并返回一个 []byte。这适用于读取小文件，对于大文件可能会消耗大量内存。

  4. os.Open 和 f.Read:

    1
    2
    3
    4
    5
    6
    7
    8
    f, err := os.Open("./tmp/dat")
    check(err)
    defer f.Close()

    b1 := make([]byte, 5)
    n1, err := f.Read(b1)
    check(err)
    pf("%d bytes: %s\n", n1, string(b1[:n1]))
    • os.Open 用于以只读模式打开一个文件，返回一个 *os.File 类型的文件对象 f。
    • defer f.Close(): 这是一个非常重要的最佳实践。defer 关键字确保在函数执行完毕后（无论是正常返回还是发生 panic），f.Close() 都会被调用，从而释放文件资源。
    • f.Read(b1): 从文件中读取最多 len(b1) 个字节到 b1 这个 byte slice 中。它返回实际读取的字节数 n1 和一个 error。

  5. f.Seek:

    1
    2
    3
    4
    5
    6
    7
    8
    o2, err := f.Seek(6, io.SeekStart)
    check(err)
    // ...
    _, err = f.Seek(2, io.SeekCurrent)
    check(err)
    // ...
    _, err = f.Seek(-4, io.SeekEnd)
    check(err)

    f.Seek 用于设置文件指针的位置。

    • 第一个参数 offset 是偏移量。
    • 第二个参数 whence 定义了起始位置：
      • io.SeekStart (0): 相对于文件起始位置。
      • io.SeekCurrent (1): 相对于当前文件指针位置。
      • io.SeekEnd (2): 相对于文件末尾位置。
        它返回新的文件指针位置和一个 error。

  6. io.ReadAtLeast:

    1
    2
    3
    4
    5
    6
    o3, err := f.Seek(6, io.SeekStart)
    check(err)
    b3 := make([]byte, 6)
    n3, err := io.ReadAtLeast(f, b3, 6)
    check(err)
    pf("%d bytes @ %d: %s\n", n3, o3, string(b3))

    io.ReadAtLeast 函数尝试从 io.Reader 中读取至少 min 个字节到给定的 buffer 中。如果读取的字节数少于 min 但没有遇到 EOF，它会返回一个错误。

  7. bufio.NewReader 和 r4.Peek:

    1
    2
    3
    4
    5
    6
    _, err = f.Seek(0, io.SeekStart)
    check(err)
    r4 := bufio.NewReader(f)
    b4, err := r4.Peek(5)
    check(err)
    fmt.Printf("5 bytes: %s\n", string(b4))
    • bufio.NewReader(f) 创建一个新的带缓冲的读取器。缓冲可以减少系统调用的次数，提高读取性能，特别是对于频繁的小块读取。
    • r4.Peek(5) 返回 Reader 缓冲区中前 5 个字节的切片，但不会移动读取指针。如果缓冲区中的数据少于 5 个字节，它会返回可用的字节。

工程中的最佳实践

  1. 及时关闭文件: 始终使用 defer f.Close() 来确保在不再需要文件时关闭它，释放系统资源。

  2. 错误处理: 示例代码中的 check 函数非常简单。在实际项目中，应该根据错误类型进行更细致的处理，例如记录日志、返回特定的错误信息等。

  3. 选择合适的读取方法:

    • 对于小文件，可以使用 os.ReadFile 一次性读取。
    • 对于大文件或需要分块处理的文件，应该使用 os.Open 并结合 f.Read 来逐步读取。
    • 如果需要提高读取性能，特别是当进行大量的小块读取时，可以使用 bufio.Reader。

  4. 处理读取的字节数: f.Read 返回实际读取的字节数。在处理读取到的数据时，应该使用实际读取的长度，例如 string(b1[:n1])，而不是假设总是读取了预期的字节数。

  5. 文件指针操作: 谨慎使用 f.Seek，理解其相对于起始位置、当前位置和末尾位置的含义。不当的文件指针操作可能导致数据读取错误。

  6. 使用 bufio 进行高效 I/O: bufio 提供的缓冲功能可以显著提高 I/O 操作的效率，尤其是在处理大量数据时。