Golang io/ioutil包源码分析

io/ioutil包

Golang JDK 1.10.3

 

/ readAll reads from r until an error or EOF and returns the data it read
// from the internal buffer allocated with a specified capacity.
func readAll(r io.Reader, capacity int64) (b []byte, err error) {
   var buf bytes.Buffer
   // If the buffer overflows, we will get bytes.ErrTooLarge.
   // Return that as an error. Any other panic remains.
   defer func() {
      e := recover()
      if e == nil {
         return
      }
      if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
         err = panicErr
      } else {
         panic(e)
      }
   }()
   if int64(int(capacity)) == capacity {
      buf.Grow(int(capacity))
   }
   _, err = buf.ReadFrom(r)
   return buf.Bytes(), err
}

readAll方法 从io.Reader  r中读取数据直到error或EOF（读完），并返回读到的数据
参数capacity 用于设置buffer的容量，可以自动扩展

 

// ReadAll reads from r until an error or EOF and returns the data it read.
// A successful call returns err == nil, not err == EOF. Because ReadAll is
// defined to read from src until EOF, it does not treat an EOF from Read
// as an error to be reported.
func ReadAll(r io.Reader) ([]byte, error) {
   return readAll(r, bytes.MinRead)
}

ReadAll方法是非常常用方法，用于从io.Reader  r中读取所有的数据并返回读取的数据
当err为nil，则读取成功
err为io.EOF，说明r中没有可以读取的数据

 

func ReadFile(filename string) ([]byte, error) {
   f, err := os.Open(filename) //打开并获取文件对象f
   if err != nil {
      return nil, err
   }
   defer f.Close()
   // It's a good but not certain bet that FileInfo will tell us exactly how much to
   // read, so let's try it but be prepared for the answer to be wrong.
   var n int64 = bytes.MinRead

   if fi, err := f.Stat(); err == nil { //获取文件状态
      // As initial capacity for readAll, use Size + a little extra in case Size
      // is zero, and to avoid another allocation after Read has filled the
      // buffer. The readAll call will read into its allocated internal buffer
      // cheaply. If the size was wrong, we'll either waste some space off the end
      // or reallocate as needed, but in the overwhelmingly common case we'll get
      // it just right.
      if size := fi.Size() + bytes.MinRead; size > n { //获取readAll缓存的capacity
         n = size
      }
   }
   return readAll(f, n)
}

ReadFile方法用于从文件中读取内容

 

func WriteFile(filename string, data []byte, perm os.FileMode) error {
   f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
   if err != nil {
      return err
   }
   n, err := f.Write(data)
   if err == nil && n < len(data) {
      err = io.ErrShortWrite
   }
   if err1 := f.Close(); err == nil {
      err = err1
   }
   return err
}

WriteFile 向文件中写入数据，写入前会清空文件。
如果文件不存在，则会以指定的权限创建该文件。
返回遇到的错误。

 

// ReadDir reads the directory named by dirname and returns
// a list of directory entries sorted by filename.
func ReadDir(dirname string) ([]os.FileInfo, error) {
   f, err := os.Open(dirname)
   if err != nil {
      return nil, err
   }
   list, err := f.Readdir(-1)
   f.Close()
   if err != nil {
      return nil, err
   }
   sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() })
   return list, nil
}

ReadDir方法用于读取文件夹下的文件信息，并按名称排序，只会读取该文件夹下的文件或文件夹，不会递归读取该文件夹下的所有文件或文件夹（只读一层）