//使用File自带的Read
func read1(filename string) int {
 fi, err := os.Open(filename)
 if err != nil {
  panic(err)
 }
 defer fi.Close()
 buf := make([]byte, 4096)
 var nbytes int
 for {
  n, err := fi.Read(buf)
  if err != nil && err != io.EOF {
   panic(err)
  }
  if n == 0 {
   break
  }
  nbytes += n

 }
 return nbytes
}

//使用bufio
func read2(filename string) int {
 fi, err := os.Open(filename)
 if err != nil {
  panic(err)
 }
 defer fi.Close()
 buf := make([]byte, 4096)
 var nbytes int
 rd := bufio.NewReader(fi)
 for {
  n, err := rd.Read(buf)
  if err != nil && err != io.EOF {
   panic(err)
  }
  if n == 0 {
   break
  }
  nbytes += n
 }
 return nbytes
}

//使用ioutil
func read3(filename string) int {
 fi, err := os.Open(filename)
 if err != nil {
  panic(err)
 }
 defer fi.Close()
 fd, err := ioutil.ReadAll(fi)
 nbytes := len(fd)
 return nbytes
}

func testfile1(filename string) {
 fmt.Printf("============test1 %s ===========\n", filename)
 start := time.Now()
 size1 := read1(filename)
 t1 := time.Now()
 fmt.Printf("Read 1 cost: %v, size: %d\n", t1.Sub(start), size1)
 size2 := read2(filename)
 t2 := time.Now()
 fmt.Printf("Read 2 cost: %v, size: %d\n", t2.Sub(t1), size2)
 size3 := read3(filename)
 t3 := time.Now()
 fmt.Printf("Read 3 cost: %v, size: %d\n", t3.Sub(t2), size3)
}

func main() {
 testfile1("small.txt")
 testfile1("midium.txt")
 testfile1("large.txt")
 // testfile2("small.txt")
 // testfile2("midium.txt")
 // testfile2("large.txt")
}

const (
 defaultBufSize = 4096
)

func NewReader(rd io.Reader) *Reader {
 return NewReaderSize(rd, defaultBufSize)
}

func NewReaderSize(rd io.Reader, size int) *Reader {
 // Is it already a Reader"color: #ff0000">总结


当读取小文件时，使用ioutil效率明显优于os和bufio，但如果是大文件，bufio读取会更快。
读取一行数据


前面简要分析了go语言三种不同读取文件方式之间的区别。但实际的开发中，我们对文件的读取往往是以行为单位的，即每次读取一行进行处理。


go语言并没有像C语言一样给我们提供好了类似于fgets这样的函数可以正好读取一行内容，因此，需要自己去实现。

从前面的对比分析可以知道，无论是处理大文件还是小文件，bufio始终是最为平滑和高效的，因此我们考虑使用bufio库进行处理。


翻阅bufio库的源码，发现可以使用如下几种方式进行读取一行文件的处理：

  
ReadBytes
  
ReadString
  
ReadSlice
  
ReadLine

效率测试


在讨论这四种读取一行文件操作的函数之前，仍然做一下效率测试。

测试代码如下：


func readline1(filename string) {
 fi, err := os.Open(filename)
 if err != nil {
  panic(err)
 }
 defer fi.Close()
 rd := bufio.NewReader(fi)
 for {
  _, err := rd.ReadBytes('\n')
  if err != nil || err == io.EOF {
   break
  }
 }
}
func readline2(filename string) {
 fi, err := os.Open(filename)
 if err != nil {
  panic(err)
 }
 defer fi.Close()
 rd := bufio.NewReader(fi)
 for {
  _, err := rd.ReadString('\n')
  if err != nil || err == io.EOF {
   break
  }
 }
}




func readline3(filename string) {
 fi, err := os.Open(filename)
 if err != nil {
  panic(err)
 }
 defer fi.Close()
 rd := bufio.NewReader(fi)
 for {
  _, err := rd.ReadSlice('\n')
  if err != nil || err == io.EOF {
   break
  }
 }
}




func readline4(filename string) {
 fi, err := os.Open(filename)
 if err != nil {
  panic(err)
 }
 defer fi.Close()
 rd := bufio.NewReader(fi)
 for {
  _, _, err := rd.ReadLine()
  if err != nil || err == io.EOF {
   break
  }
 }
}


可以看到，这四种操作方式，无论是函数调用，还是函数返回值的处理，其实都是大同小异的。但通过测试效率，则可以看出它们之间的区别。


我们使用下面的测试代码：


func testfile2(filename string) {
 fmt.Printf("============test2 %s ===========\n", filename)
 start := time.Now()
 readline1(filename)
 t1 := time.Now()
 fmt.Printf("Readline 1 cost: %v\n", t1.Sub(start))
 readline2(filename)
 t2 := time.Now()
 fmt.Printf("Readline 2 cost: %v\n", t2.Sub(t1))
 readline3(filename)
 t3 := time.Now()
 fmt.Printf("Readline 3 cost: %v\n", t3.Sub(t2))
 readline4(filename)
 t4 := time.Now()
 fmt.Printf("Readline 4 cost: %v\n", t4.Sub(t3))
}



在main函数中调用如下：


func main() {
 // testfile1("small.txt")
 // testfile1("midium.txt")
 // testfile1("large.txt")
 testfile2("small.txt")
 testfile2("midium.txt")
 testfile2("large.txt")
}



运行结果如下所示：



通过现象，除了small.txt之外，大致可以分为两组：

  
ReadBytes对小文件处理效率最差
  
在处理大文件时，ReadLine和ReadSlice效率相近，要明显快于ReadString和ReadBytes。

原因分析


为什么会出现上面的现象，不防从源码层面进行分析。

通过阅读源码，我们发现这四个函数之间存在这样一个关系：

  
ReadLine <- (调用) ReadSlice
  
ReadString <- (调用)ReadBytes<-(调用)ReadSlice

既然如此，那为什么在处理大文件时，ReadLine效率要明显高于ReadBytes呢？
首先，我们要知道，ReadSlice是切片式读取，即根据分隔符去进行切片。

通过源码发下，ReadLine只是在切片读取的基础上，对换行符\n和\r\n做了一些处理：


func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) {
 line, err = b.ReadSlice('\n')
 if err == ErrBufferFull {
  // Handle the case where "\r\n" straddles the buffer.
  if len(line) > 0 && line[len(line)-1] == '\r' {
   // Put the '\r' back on buf and drop it from line.
   // Let the next call to ReadLine check for "\r\n".
   if b.r == 0 {
    // should be unreachable
    panic("bufio: tried to rewind past start of buffer")
   }
   b.r--
   line = line[:len(line)-1]
  }
  return line, true, nil
 }

 if len(line) == 0 {
  if err != nil {
   line = nil
  }
  return
 }
 err = nil

 if line[len(line)-1] == '\n' {
  drop := 1
  if len(line) > 1 && line[len(line)-2] == '\r' {
   drop = 2
  }
  line = line[:len(line)-drop]
 }
 return
}



而ReadBytes则是通过append先将读取的内容暂存到full数组中，最后再copy出来，append和copy都是要消耗内存和io的，因此效率自然就慢了。其源码如下所示：


func (b *Reader) ReadBytes(delim byte) ([]byte, error) {
 // Use ReadSlice to look for array,
 // accumulating full buffers.
 var frag []byte
 var full [][]byte
 var err error
 n := 0
 for {
  var e error
  frag, e = b.ReadSlice(delim)
  if e == nil { // got final fragment
   break
  }
  if e != ErrBufferFull { // unexpected error
   err = e
   break
  }

  // Make a copy of the buffer.
  buf := make([]byte, len(frag))
  copy(buf, frag)
  full = append(full, buf)
  n += len(buf)
 }

 n += len(frag)

 // Allocate new buffer to hold the full pieces and the fragment.
 buf := make([]byte, n)
 n = 0
 // Copy full pieces and fragment in.
 for i := range full {
  n += copy(buf[n:], full[i])
 }
 copy(buf[n:], frag)
 return buf, err
}



总结


读取文件中一行内容时，ReadSlice和ReadLine性能优于ReadBytes和ReadString，但由于ReadLine对换行的处理更加全面（兼容\n和\r\n换行），因此，实际开发过程中，建议使用ReadLine函数。
 到此这篇关于Go语言文件读取的一些总结的文章就介绍到这了,更多相关Go语言文件读取内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！