超全总结:Go 读文件的 10 种方法

开发 后端
Go 中对文件内容读写的方法,非常地多,其中大多数是基于 syscall 或者 os 库的高级封装,不同的库,适用的场景又不太一样,为免新手在这块上裁跟头,我花了点时间把这些内容梳理了下。

[[442758]]

大家好,我是明哥。

Go 中对文件内容读写的方法,非常地多,其中大多数是基于 syscall 或者 os 库的高级封装,不同的库,适用的场景又不太一样,为免新手在这块上裁跟头,我花了点时间把这些内容梳理了下。

这篇是上篇,先介绍读取文件的 10 种方法,过两天再介绍写入文件的。

 1. 整个文件读取入内存

直接将数据直接读取入内存,是效率最高的一种方式,但此种方式,仅适用于小文件,对于大文件,则不适合,因为比较浪费内存。

1.1 直接指定文件名读取

有两种方法

第一种:使用 os.ReadFile

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "os" 
  6.  
  7. func main() { 
  8.     content, err := os.ReadFile("a.txt"
  9.     if err != nil { 
  10.         panic(err) 
  11.     } 
  12.     fmt.Println(string(content)) 

第二种:使用 ioutil.ReadFile

  1. package main 
  2.  
  3. import ( 
  4.     "io/ioutil" 
  5.     "fmt" 
  6.  
  7. func main() { 
  8.     content, err := ioutil.ReadFile("a.txt"
  9.     if err != nil { 
  10.         panic(err) 
  11.     } 
  12.     fmt.Println(string(content)) 

其实在 Go 1.16 开始,ioutil.ReadFile 就等价于 os.ReadFile,二者是完全一致的

  1. // ReadFile reads the file named by filename and returns the contents. 
  2. // A successful call returns err == nil, not err == EOF. Because ReadFile 
  3. // reads the whole file, it does not treat an EOF from Read as an error 
  4. // to be reported. 
  5. // 
  6. // As of Go 1.16, this function simply calls os.ReadFile. 
  7. func ReadFile(filename string) ([]byte, error) { 
  8.     return os.ReadFile(filename) 

1.2 先创建句柄再读取

如果仅是读取,可以使用高级函数 os.Open

  1. package main 
  2.  
  3. import ( 
  4. "os" 
  5. "io/ioutil" 
  6. "fmt" 
  7.  
  8. func main() { 
  9.     file, err := os.Open("a.txt"
  10.     if err != nil { 
  11.         panic(err) 
  12.     } 
  13.     defer file.Close() 
  14.     content, err := ioutil.ReadAll(file) 
  15.     fmt.Println(string(content)) 

之所以说它是高级函数,是因为它是只读模式的 os.OpenFile

  1. // Open opens the named file for reading. If successful, methods on 
  2. // the returned file can be used for reading; the associated file 
  3. // descriptor has mode O_RDONLY. 
  4. // If there is an error, it will be of type *PathError. 
  5. func Open(name string) (*File, error) { 
  6.     return OpenFile(name, O_RDONLY, 0) 

因此,你也可以直接使用 os.OpenFile,只是要多加两个参数

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "io/ioutil" 
  6.     "os" 
  7.  
  8. func main() { 
  9.     file, err := os.OpenFile("a.txt", os.O_RDONLY, 0) 
  10.     if err != nil { 
  11.         panic(err) 
  12.     } 
  13.     defer file.Close() 
  14.     content, err := ioutil.ReadAll(file) 
  15.     fmt.Println(string(content)) 

2. 每次只读取一行

一次性读取所有的数据,太耗费内存,因此可以指定每次只读取一行数据。方法有三种:

  • bufio.ReadLine()
  • bufio.ReadBytes('\n')
  • bufio.ReadString('\n')

在 bufio 的源码注释中,曾说道 bufio.ReadLine() 是低级库,不太适合普通用户使用,更推荐用户使用 bufio.ReadBytes 和 bufio.ReadString 去读取单行数据。

因此,这里不再介绍 bufio.ReadLine()

2.1 使用 bufio.ReadBytes

  1. package main 
  2.  
  3. import ( 
  4.     "bufio" 
  5.     "fmt" 
  6.     "io" 
  7.     "os" 
  8.     "strings" 
  9.  
  10. func main() { 
  11.     // 创建句柄 
  12.     fi, err := os.Open("christmas_apple.py"
  13.     if err != nil { 
  14.         panic(err) 
  15.     } 
  16.  
  17.     // 创建 Reader 
  18.     r := bufio.NewReader(fi) 
  19.  
  20.     for { 
  21.         lineBytes, err := r.ReadBytes('\n'
  22.         line := strings.TrimSpace(string(lineBytes)) 
  23.         if err != nil && err != io.EOF { 
  24.             panic(err) 
  25.         } 
  26.         if err == io.EOF { 
  27.             break 
  28.         } 
  29.         fmt.Println(line) 
  30.     } 

2.2 使用 bufio.ReadString

  1. package main 
  2.  
  3. import ( 
  4.     "bufio" 
  5.     "fmt" 
  6.     "io" 
  7.     "os" 
  8.     "strings" 
  9.  
  10. func main() { 
  11.     // 创建句柄 
  12.     fi, err := os.Open("a.txt"
  13.     if err != nil { 
  14.         panic(err) 
  15.     } 
  16.  
  17.     // 创建 Reader 
  18.     r := bufio.NewReader(fi) 
  19.  
  20.     for { 
  21.         line, err := r.ReadString('\n'
  22.         line = strings.TrimSpace(line) 
  23.         if err != nil && err != io.EOF { 
  24.             panic(err) 
  25.         } 
  26.         if err == io.EOF { 
  27.             break 
  28.         } 
  29.         fmt.Println(line) 
  30.     } 

3. 每次只读取固定字节数

每次仅读取一行数据,可以解决内存占用过大的问题,但要注意的是,并不是所有的文件都有换行符 \n。

因此对于一些不换行的大文件来说,还得再想想其他办法。

3.1 使用 os 库

通用的做法是:

  • 先创建一个文件句柄,可以使用 os.Open 或者 os.OpenFile
  • 然后 bufio.NewReader 创建一个 Reader
  • 然后在 for 循环里调用 Reader 的 Read 函数,每次仅读取固定字节数量的数据。
  1. package main 
  2.  
  3. import ( 
  4.     "bufio" 
  5.     "fmt" 
  6.     "io" 
  7.     "os" 
  8.  
  9. func main() { 
  10.     // 创建句柄 
  11.     fi, err := os.Open("a.txt"
  12.     if err != nil { 
  13.         panic(err) 
  14.     } 
  15.  
  16.     // 创建 Reader 
  17.     r := bufio.NewReader(fi) 
  18.  
  19.     // 每次读取 1024 个字节 
  20.     buf := make([]byte, 1024) 
  21.     for { 
  22.         n, err := r.Read(buf) 
  23.         if err != nil && err != io.EOF { 
  24.             panic(err) 
  25.         } 
  26.  
  27.         if n == 0 { 
  28.             break 
  29.         } 
  30.         fmt.Println(string(buf[:n])) 
  31.     } 

3.2 使用 syscall 库

os 库本质上也是调用 syscall 库,但由于 syscall 过于底层,如非特殊需要,一般不会使用 syscall

本篇为了内容的完整度,这里也使用 syscall 来举个例子。

本例中,会每次读取 100 字节的数据,并发送到通道中,由另外一个协程进行读取并打印出来。

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "sync" 
  6.     "syscall" 
  7.  
  8. func main() { 
  9.     fd, err := syscall.Open("christmas_apple.py", syscall.O_RDONLY, 0) 
  10.     if err != nil { 
  11.         fmt.Println("Failed on open: ", err) 
  12.     } 
  13.     defer syscall.Close(fd) 
  14.  
  15.     var wg sync.WaitGroup 
  16.     wg.Add(2) 
  17.     dataChan := make(chan []byte) 
  18.     go func() { 
  19.         wg.Done() 
  20.         for { 
  21.             data := make([]byte, 100) 
  22.             n, _ := syscall.Read(fd, data) 
  23.             if n == 0 { 
  24.                 break 
  25.             } 
  26.             dataChan <- data 
  27.         } 
  28.         close(dataChan) 
  29.     }() 
  30.  
  31.     go func() { 
  32.         defer wg.Done() 
  33.         for { 
  34.             select { 
  35.             case data, ok := <-dataChan: 
  36.                 if !ok { 
  37.                     return 
  38.                 } 
  39.  
  40.                 fmt.Printf(string(data)) 
  41.             default
  42.  
  43.             } 
  44.         } 
  45.     }() 
  46.     wg.Wait() 
本文转载自微信公众号「Go编程时光」,可以通过以下二维码关注。转载本文请联系Go编程时光公众号。

 

责任编辑:武晓燕 来源: Go编程时光
相关推荐

2020-09-15 15:50:33

Python编程语言代码

2024-03-01 20:55:40

Pytorch张量Tensor

2024-06-11 07:34:58

C#字符串性能

2024-05-10 12:59:58

PyTorch人工智能

2022-05-31 16:00:46

Go 编程语言复制文件Go 标准库

2020-05-15 08:28:18

二进制文件binLinux

2017-06-09 13:51:42

Linux命令删除文件

2019-10-24 08:52:23

Linux压缩文件归档

2020-11-10 10:23:25

IT成本CIO高级分析师

2020-05-06 09:51:37

二进制Linux命令行工具

2011-09-02 14:59:15

2009-12-25 10:28:10

WPF路由事件

2022-01-16 09:30:34

Ansible自动化工具开源

2021-07-26 09:47:38

Go语言C++

2024-03-22 15:32:21

机器学习算法

2014-06-23 16:56:46

2009-11-23 15:57:51

PHP伪静态

2023-08-15 08:01:07

Go 语言排序

2009-10-21 17:02:51

综合布线施工经验

2024-08-29 08:04:14

点赞
收藏

51CTO技术栈公众号