关于go:Go-读取文本文件的三种方式

Go 读取文本文件

工作中时不时须要读取文本，文本文件是最常见的文件类型。

本文将从逐行、一一单词和一一字符三个办法读取文件：

• byLine.go
• byWord.go
• byCharacter.go

1 逐行读取文本文件

逐行读取文件是最为常见的文本文件，也是最为简略的形式。首先咱们须要导入几个常见的包：

• bufio：缓存区读写文件
• flag：命令行参数解析

package main

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

func lineByLine(file string) error {

  var err error

  f, err := os.Open(file)
  if err != nil {return err}

  defer f.Close()

  r := bufio.NewReader(f)
  for {line, err := r.ReadString('\n')
    if err == io.EOF {break} else if err != nil {fmt.Printf("error reading file %s", err)
      break
    }
    fmt.Print(line)
  }
  return nil
}

func main() {flag.Parse()
  if len(flag.Args()) == 0 {fmt.Printf("usage: byLine <file1> [<file2> ...]\n")
    return
  }

  for _, file := range flag.Args() {err := lineByLine(file)
    if err != nil {fmt.Println(err)
    }
  }
}

代码解释：

• 次要通过 bufio.NewReader() 函数生成一个新的读取器；
• 随后，在 bufio.ReadString() 函数读取字符，告诉该函数继续执行读取工作，直到碰到该 “\n” 参数，也就是换行符。读到换行符，执行文本输入。
• 如果读取中断了，即 err == io.EOF , 退出文件读取
• 或者 err != nil, 打印谬误提醒，退出文件执行

main() 函数中首先读取命令行参数，如果命令行长度为 0，即没有传入要读取的文件，如果此时执行 byLine.go 文件的话就会给出语法提醒，如下:

$ go run byLine.go
usage: byLine <file1> [<file2> ...]

咱们写一个测试的文本文件 test.txt, 写入如下几行数据，记得在第二行换行（退出空行）：

 这是第一行
我是第二行 

运行如下命令后，后果为：

$ go run byLine.go test.txt
这是第一行
我是第二行 

能够应用 cat test.txt 校验咱们的后果的准确性，如下：

$ cat test.txt
这是第一行
我是第二行 

2 一一单词读取文本文件

package main

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

func wordByWord(file string) error {
  var err error
  f, err := os.Open(file)
  if err != nil {return err}

  defer f.Close()
  scanner := bufio.NewScanner(f)
  scanner.Split(bufio.ScanWords)
  var words []string
  for scanner.Scan() {words = append(words, scanner.Text())
  }

  for _, word := range words {fmt.Println(word)
  }
  return nil
}

func main() {flag.Parse()
  if len(flag.Args()) == 0 {fmt.Printf("usage: byWord <file1> [file2> ...]\n")
    return
  }

  for _, file := range flag.Args() {err := wordByWord(file)
    if err != nil {fmt.Println(err)
    }
  }
}

代码解释：

• 其余代码都和 byLine.go 函数一样，次要是利用了 bufio 中的 scanner 来扫描单词，
• scanner := bufio.NewScanner(file) 用来扫描读取的文件
• scanner.Split(bufio.ScanWords) 用来宰割单词
• 申明一个单词字符串列表，将读取到的每一个单词放入这个列表中
• 循环遍历单词字符串列表，打印每一个单词

测试代码

写入一个 test.txt 文件：

Hello World
1 2 3 

运行代码，结果显示：

$ go run byWord.go test.txt
Hello
World
1
2
3

3 一一字符读取文本文件

一一字符读取文本的应用场景还是很少，除非开发一个文本编辑器。新建一个 byCharacter.go 文件，而后写入如下代码：

package main

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

func charByChar(file string) error {

  var err error
  f, err := os.Open(file)
  if err != nil {return err}

  defer f.Close()

  r := bufio.NewReader(f)
  for {line, err := r.ReadString('\n')
    if err == io.EOF {break} else if err != nil {fmt.Printf("error reading file %s", err)
      return err
    }

    for _, x := range line {fmt.Println(string(x))
    }
  }
  return nil
}

func main() {flag.Parse()
  if len(flag.Args()) == 0 {fmt.Printf("usage: byWord <file1> [file2> ...]\n")
    return
  }

  for _, file := range flag.Args() {err := charByChar(file)
    if err != nil {fmt.Println(err)
    }
  }
}

运行测试用例得出的最初后果为：

$ go run byCharacter.go test.txt 
H
e
l
l
o
 
W
o
r
l
d

总结

本文次要介绍 Go 中的 bufio 包，有些状况下，咱们并不只是须要读取整个一大段文件，所以须要把文件通过某种形式读取，并介绍了 Go 读取文本文件中的三种办法：

• 逐行读取文本文件 byLine.go
• 一一单词读取文本文件 byWord.go
• 一一字符读取文本文件 byCharacter.go

其实还有更多读取文本文件的办法，比方通过逗号读取、读取特定数据量的文本，这些办法留到后文再作介绍，下一篇文章见！