首页 > 脚本中心 > Golang > Go语言实现读取文件的方式总结

Go语言实现读取文件的方式总结

福牛 4月 06, 2023 48 0

前言

这篇文章将讨论如何在 golang 中读取文件。我们将使用以下包来处理这些文件。

  • os 包提供了一个独立于平台的接口来执行操作级操作。
  • IOutil 软件包提供了易于使用的实用程序函数来处理文件，而无需了解太多内部实现。
  • bufio 包实现了缓冲 IO，这有助于我们提高输入和输出操作的性能和吞吐量。
  • log 包实现一个简单的日志记录包。我们将在整个程序中使用它。我们将在程序中使用日志包的 Fatal() 函数。

整个文件读取

我们可以很容易地一次性读取整个文件并将其存储在一个变量中。但请记住，我们不应该对大文件这样做。我们将使用ioutil.ReadFile() 函数来读取文件并将文件的内容存储在一个变量中。

首先，让我们在我们程序所在的同一目录下存储一个文件。因此，我们的文件夹结构将是下面这样的。

___
|
|_ _ _ _ ilovego.txt |
|_ _ _ _ main.go

我们在 main.go 函数中写入如下的内容：

  1. package main
  2.  
  3. import (
  4.      “fmt”
  5.      “io/ioutil“
  6.      “log”
  7. )
  8.  
  9. func main() {
  10.  
  11.      content, err := ioutil.ReadFile(“ilovego.txt”)
  12.  
  13.      if err != nil {
  14.          log.Fatal(err)
  15.      }
  16.  
  17.      fmt.Println(string(content))
  18. }

但首先，让我们讨论一下 ReadFile() 函数的情况：

  • 定义：方法声明 func ReadFile(filename string) ([]byte, error)
  • 功能：读取路径被传入函数参数的文件，并返回文件的内容。在内部使用 os.ReadFile(fileName) 方法
  • 返回：在一个字节数组中返回文件的内容和错误。一个成功的调用将返回 err == nil

内部 ReadFile 函数实现如下:

  1. func ReadFile(filename string) ([]byte, error) {
  2.      return os.ReadFile(filename)
  3. }

现在，让我们回到我们的程序:

  • ioutil.ReadFile("readthisfile.txt") 返回一个 byteArray 和一个 err。我们将byteArray 存储在 “content “变量中，错误存储在 ” err “变量中。
  • 然后我们放置了一个 if 条件，如果 err 值不为 nil，我们将使用 log.Fatal() 函数打印错误 err 。记住，Fatal() 函数等同于 Print() 函数，然后调用 os.Exit(1) 。
  • 最后，我们将使用 fmt.Println() 函数打印文件的内容。 我们不能简单地打印 content 变量，因为它是一个字节数组，我们需要将它转换为字符串: string(content)

然后新建一个 ilovego.txt 文件，写入如下内容：

I Love Golang,
This is One of the Best Languages on the World!

最后，执行上述代码，可以看到如下输出：

$ go run main.go
I Love Golang,
This is One of the Best Languages on the World!

按行读取

Scanner 扫描器提供了一个方便的接口来读取数据，比如一个由新行分隔的文本行组成的文件。它通过标记来读取数据；Split 函数定义了标记。默认情况下，该函数将数据分成几行，并剥离了行端。

  1. package main
  2.  
  3. import (
  4.      “fmt”
  5.      // “io/ioutil”
  6.      “bufio”
  7.      “log”
  8.      “os”
  9. )
  10.  
  11. func main() {
  12.  
  13.      // opening the file using Open function
  14.      f, err := os.Open(“ilovego.txt”)
  15.  
  16.      if err != nil {
  17.          log.Fatal(err)
  18.      }
  19.  
  20.      defer f.Close()
  21.  
  22.      // create a scanner for the file
  23.      scanner := bufio.NewScanner(f)
  24.  
  25.      // loop through the scanner until it return fasle
  26.      for scanner.Scan() {
  27.  
  28.          fmt.Println(scanner.Text())
  29.      }
  30.  
  31.      if err := scanner.Err(); err != nil {
  32.          log.Fatal(err)
  33.      }
  34. }
  • os.Open() 打开参数中传递的文件。如果在打开文件时遇到任何错误，它将返回同样的错误。否则，错误将是 nil。
  • 然后，我们使用扫描器来读取文件，并逐行扫描，直到文件内容结束。
  • 最后，我们要关闭该文件。

执行程序，结果如下：

-1

逐个单词读取

我们还可以通过逐个单词来读取文件：

  1. package main
  2.  
  3. import (
  4.      “bufio”
  5.      “fmt”
  6.      “os”
  7. )
  8.  
  9. func main() {
  10.  
  11.      f, err := os.Open(“ilovego.txt”)
  12.  
  13.      if err != nil {
  14.          fmt.Println(err)
  15.      }
  16.  
  17.      defer f.Close()
  18.  
  19.      scanner := bufio.NewScanner(f)
  20.      scanner.Split(bufio.ScanWords)
  21.  
  22.      for scanner.Scan() {
  23.  
  24.          fmt.Println(scanner.Text())
  25.      }
  26.  
  27.      if err := scanner.Err(); err != nil {
  28.          fmt.Println(err)
  29.      }
  30. }

运行代码：

$ go run main.go
I
Love
Golang,
This
is
One
of
the
Best
Languages
on
the
World!

以数据块的形式读取文件

一次性读取整个文件似乎是一种简单的方法，但有时我们需要从内存管理的角度使我们的程序得到一些优化。Golang 提供了一种分块读取文件的方法，而不是整个或甚至逐行读取。因为如果一行的大小太大，逐行读取也可能是低效的。

  1. package main
  2.  
  3. import (
  4.      “bufio”
  5.      “fmt”
  6.      “io”
  7.      “log”
  8.      “os”
  9. )
  10.  
  11. func main() {
  12.  
  13.      f, err := os.Open(“ilovego.txt”)
  14.  
  15.      if err != nil {
  16.          log.Fatal(err)
  17.      }
  18.  
  19.      defer f.Close()
  20.  
  21.      reader := bufio.NewReader(f)
  22.      buf := make([]byte, 16)
  23.  
  24.      for {
  25.                  // reading a file upto buffer
  26.          n, err := reader.Read(buf)
  27.  
  28.          if err != nil {
  29.  
  30.              if err != io.EOF {
  31.  
  32.                  log.Fatal(err)
  33.              }
  34.  
  35.              break
  36.          }
  37.  
  38.          fmt.Print(string(buf[0:n]))
  39.      }
  40.  
  41.      fmt.Println()
  42. }

二进制读取

hex 包实现了十六进制的编码和解码。

  1. package main
  2.  
  3. import (
  4.      “bufio”
  5.      “encoding/hex”
  6.      “fmt”
  7.      “io”
  8.      “log”
  9.      “os”
  10. )
  11.  
  12. func main() {
  13.  
  14.      f, err := os.Open(“sid.jpg”)
  15.  
  16.      if err != nil {
  17.          log.Fatal(err)
  18.      }
  19.  
  20.      defer f.Close()
  21.  
  22.      reader := bufio.NewReader(f)
  23.      buf := make([]byte, 256)
  24.  
  25.      for {
  26.          _, err := reader.Read(buf)
  27.  
  28.          if err != nil {
  29.              if err != io.EOF {
  30.                  fmt.Println(err)
  31. }
  32.              break
  33.          }
  34.  
  35.          fmt.Printf(“%s”, hex.Dump(buf))
  36.      }
  37. }

总结

本文介绍了 Go 语言读取文件的几种方式，ioutil.ReadFile 函数将整个文件读成一个字符串。这个函数很方便，但不应该用于非常大的文件。希望能对你有所帮助！

到此这篇关于Go语言实现读取文件的方式总结的文章就介绍到这了,更多相关Go语言读取文件内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论