7.8 处理文件

文件的读写是编程语言的常见操作之一，这里讲一些Goang 读取文件的相关操作。

读取文件

读取文件有三种方式：

  • 将文件整个读入内存
  • 按字节数读取
  • 按行读取

具体实现如下：

1、将文件整个读入内存
  1. package main
  3. import (
  4.    "os"
  5.    "io/ioutil"
  6.    "fmt"
  7. )
  9. func main() {
  10.    file, err := os.Open("D:/gopath/src/golang_development_notes/example/log.txt")
  11.    if err != nil {
  12.       panic(err)
  13.    }
  14.    defer file.Close()
  15.    content, err := ioutil.ReadAll(file)
  16.    fmt.Println(string(content))
  17. }

或者

  1. package main
  3. import (
  4.    "os"
  5.    "io/ioutil"
  6.    "fmt"
  7. )
  9. func main() {
  10.    filepath := "D:/gopath/src/golang_development_notes/example/log.txt"
  11.    content ,err :=ioutil.ReadFile(filepath)
  12.    if err !=nil {
  13.       panic(err)
  14.    }
  15.    fmt.Println(string(content))
  16. }

将文件整个读入内存，效率比较高，占用内存也最高。

2、按字节读取文件

  1. package main
  3. import (
  4.    "bufio"
  5.    "fmt"
  6.    "io"
  7.    "io/ioutil"
  8.    "os"
  9. )
  11. func main() {
  12.    filepath := "D:/gopath/src/golang_development_notes/example/log.txt"
  13.    fi, err := os.Open(filepath)
  14.    if err != nil {
  15.       panic(err)
  16.    }
  17.    defer fi.Close()
  18.    r := bufio.NewReader(fi)
  20.    chunks := make([]byte, 0)
  21.    buf := make([]byte, 1024) //一次读取多少个字节
  22.    for {
  23.       n, err := r.Read(buf)
  24.       if err != nil && err != io.EOF {
  25.          panic(err)
  26.       }
  27.       fmt.Println(string(buf[:n]))
  28.       break
  29.       if 0 == n {
  30.          break
  31.       }
  32.       chunks = append(chunks, buf[:n]...)
  33.    }
  34.    fmt.Println(string(chunks))
  35. }

或

  1. package main
  3. import (
  4.    "fmt"
  5.    "io"
  6.    "os"
  7. )
  9. func main() {
  11.    file := "D:/gopath/src/golang_development_notes/example/log.txt"
  12.    f, err := os.Open(file)
  13.    if err != nil {
  14.       panic(err)
  15.    }
  16.    defer f.Close()
  18.    chunks := make([]byte, 0)
  19.    buf := make([]byte, 1024)
  20.    for {
  21.       n, err := f.Read(buf)
  22.       if err != nil && err != io.EOF {
  23.          panic(err)
  24.       }
  25.       if 0 == n {
  26.          break
  27.       }
  28.       chunks = append(chunks, buf[:n]...)
  29.    }
  30.    fmt.Println(string(chunks))
  31. }

3、按行读取

  1. package main
  3. import (
  4.    "bufio"
  5.    "fmt"
  6.    "io"
  7.    "io/ioutil"
  8.    "os"
  9.    "strings"
  10. )
  12. func main() {
  13.    filepath := "D:/gopath/src/golang_development_notes/example/log.txt"
  14.    file, err := os.OpenFile(filepath, os.O_RDWR, 0666)
  15.    if err != nil {
  16.       fmt.Println("Open file error!", err)
  17.       return
  18.    }
  19.    defer file.Close()
  21.    stat, err := file.Stat()
  22.    if err != nil {
  23.       panic(err)
  24.    }
  25.    var size = stat.Size()
  26.    fmt.Println("file size=", size)
  28.    buf := bufio.NewReader(file)
  29.    for {
  30.       line, err := buf.ReadString('\n')
  31.       line = strings.TrimSpace(line)
  32.       fmt.Println(line)
  33.       if err != nil {
  34.          if err == io.EOF {
  35.             fmt.Println("File read ok!")
  36.             break
  37.          } else {
  38.             fmt.Println("Read file error!", err)
  39.             return
  40.          }
  41.       }
  42.    }
  44. }

写入文件

有以下写入方式

1、ioutil.WriteFile

  1. package main
  3. import (
  4.    "io/ioutil"
  5. )
  7. func main() {
  9.    content := []byte("测试1\n测试2\n")
  10.    err := ioutil.WriteFile("test.txt", content, 0644)
  11.    if err != nil {
  12.       panic(err)
  13.    }
  14. }

这种方式每次都会覆盖 test.txt内容，如果test.txt文件不存在会创建。

2、os

  1. package main
  3. import (
  4.    "fmt"
  5.    "io"
  6.    "os"
  7. )
  9. func checkFileIsExist(filename string) bool {
  10.    if _, err := os.Stat(filename); os.IsNotExist(err) {
  11.       return false
  12.    }
  13.    return true
  14. }
  15. func main() {
  16.    var wireteString = "测试1\n测试2\n"
  17.    var filename = "./test.txt"
  18.    var f *os.File
  19.    var err1 error
  20.    if checkFileIsExist(filename) { //如果文件存在
  21.       f, err1 = os.OpenFile(filename, os.O_APPEND, 0666) //打开文件
  22.       fmt.Println("文件存在")
  23.    } else {
  24.       f, err1 = os.Create(filename) //创建文件
  25.       fmt.Println("文件不存在")
  26.    }
  27.    defer f.Close()
  28.    n, err1 := io.WriteString(f, wireteString) //写入文件(字符串)
  29.    if err1 != nil {
  30.       panic(err1)
  31.    }
  32.    fmt.Printf("写入 %d 个字节n", n)
  33. }

此种方法可以在文件内容末尾添加新内容。

3、

  1. package main
  3. import (
  4.    "fmt"
  5.    "os"
  6. )
  8. func checkFileIsExist(filename string) bool {
  9.    if _, err := os.Stat(filename); os.IsNotExist(err) {
  10.       return false
  11.    }
  12.    return true
  13. }
  14. func main() {
  15.    var str = "测试1\n测试2\n"
  16.    var filename = "./test.txt"
  17.    var f *os.File
  18.    var err1 error
  19.    if checkFileIsExist(filename) { //如果文件存在
  20.       f, err1 = os.OpenFile(filename, os.O_APPEND, 0666) //打开文件
  21.       fmt.Println("文件存在")
  22.    } else {
  23.       f, err1 = os.Create(filename) //创建文件
  24.       fmt.Println("文件不存在")
  25.    }
  26.    defer f.Close()
  27.    n, err1 := f.Write([]byte(str)) //写入文件(字节数组)
  29.    fmt.Printf("写入 %d 个字节n", n)
  30.    n, err1 = f.WriteString(str) //写入文件(字符串)
  31.    if err1 != nil {
  32.       panic(err1)
  33.    }
  34.    fmt.Printf("写入 %d 个字节n", n)
  35.    f.Sync()
  36. }

此种方法可以在文件内容末尾添加新内容。

4、bufio

  1. package main
  3. import (
  4.    "bufio"
  5.    "fmt"
  6.    "os"
  7. )
  9. func checkFileIsExist(filename string) bool {
  10.    if _, err := os.Stat(filename); os.IsNotExist(err) {
  11.       return false
  12.    }
  13.    return true
  14. }
  15. func main() {
  16.    var str = "测试1\n测试2\n"
  17.    var filename = "./test.txt"
  18.    var f *os.File
  19.    var err1 error
  20.    if checkFileIsExist(filename) { //如果文件存在
  21.       f, err1 = os.OpenFile(filename, os.O_APPEND, 0666) //打开文件
  22.       fmt.Println("文件存在")
  23.    } else {
  24.       f, err1 = os.Create(filename) //创建文件
  25.       fmt.Println("文件不存在")
  26.    }
  27.    defer f.Close()
  28.    if err1 != nil {
  29.       panic(err1)
  30.    }
  31.    w := bufio.NewWriter(f) //创建新的 Writer 对象
  32.    n, _ := w.WriteString(str)
  33.    fmt.Printf("写入 %d 个字节n", n)
  34.    w.Flush()
  35. }

此种方法可以在文件内容末尾添加新内容。

对比几种读取文件效率

  1. package main
  3. import (
  4.    "bufio"
  5.    "fmt"
  6.    "io"
  7.    "io/ioutil"
  8.    "os"
  9.    "time"
  10. )
  12. func read0(path string) string {
  13.    file, err := os.Open(path)
  14.    if err != nil {
  15.       panic(err)
  16.    }
  17.    defer file.Close()
  18.    content, err := ioutil.ReadAll(file)
  19.    return string(content)
  20. }
  22. func read1(path string) string {
  23.    content, err := ioutil.ReadFile(path)
  24.    if err != nil {
  25.       panic(err)
  26.    }
  27.    return string(content)
  28. }
  30. func read2(path string) string {
  31.    fi, err := os.Open(path)
  32.    if err != nil {
  33.       panic(err)
  34.    }
  35.    defer fi.Close()
  36.    r := bufio.NewReader(fi)
  38.    chunks := make([]byte, 0)
  39.    buf := make([]byte, 1024) //一次读取多少个字节
  40.    for {
  41.       n, err := r.Read(buf)
  42.       if err != nil && err != io.EOF {
  43.          panic(err)
  44.       }
  45.       if 0 == n {
  46.          break
  47.       }
  48.       chunks = append(chunks, buf[:n]...)
  49.    }
  50.    return string(chunks)
  51. }
  53. func read3(path string) string {
  54.    fi, err := os.Open(path)
  55.    if err != nil {
  56.       panic(err)
  57.    }
  58.    defer fi.Close()
  60.    chunks := make([]byte, 0)
  61.    buf := make([]byte, 1024)
  62.    for {
  63.       n, err := fi.Read(buf)
  64.       if err != nil && err != io.EOF {
  65.          panic(err)
  66.       }
  67.       if 0 == n {
  68.          break
  69.       }
  70.       chunks = append(chunks, buf[:n]...)
  71.    }
  72.    return string(chunks)
  73. }
  75. func main() {
  77.    file := "D:/gopath/src/example/example/log.txt"
  79.    start := time.Now()
  81.    read0(file)
  82.    t0 := time.Now()
  83.    fmt.Printf("Cost time %v\n", t0.Sub(start))
  85.    read1(file)
  86.    t1 := time.Now()
  87.    fmt.Printf("Cost time %v\n", t1.Sub(t0))
  89.    read2(file)
  90.    t2 := time.Now()
  91.    fmt.Printf("Cost time %v\n", t2.Sub(t1))
  93.    read3(file)
  94.    t3 := time.Now()
  95.    fmt.Printf("Cost time %v\n", t3.Sub(t2))
  97. }

运行结果：

第一次

Cost time 6.0003ms Cost time 3.0002ms Cost time 7.0004ms Cost time 11.0006ms

第二次

Cost time 7.0004ms Cost time 4.0003ms Cost time 6.0003ms Cost time 8.0005ms

第三次

Cost time 9.0006ms Cost time 3.0001ms Cost time 7.0004ms Cost time 11.0007ms

links