为什么要避免在 Go 中使用 ioutil.ReadAll？

func main() {
  res, err := http.Get("http://www.google.com/robots.txt")
  if err != nil {
    log.Fatal(err)
  }
  robots, err := io.ReadAll(res.Body)
  res.Body.Close()
  if err != nil {
    log.Fatal(err)
  }
  fmt.Printf("%s", robots)
}
复制代码

// src/io/ioutil/ioutil.go
func ReadAll(r io.Reader) ([]byte, error) {
  return io.ReadAll(r)
}
复制代码

// src/io/io.go
func ReadAll(r Reader) ([]byte, error) {
    // 创建一个 512 字节的 buf
  b := make([]byte, 0, 512)
  for {
    if len(b) == cap(b) {
      // 如果 buf 满了，则追加一个元素，使其重新分配内存
      b = append(b, 0)[:len(b)]
    }
    // 读取内容到 buf
    n, err := r.Read(b[len(b):cap(b)])
    b = b[:len(b)+n]
    // 遇到结尾或者报错则返回
    if err != nil {
      if err == EOF {
        err = nil
      }
      return b, err
    }
  }
}
复制代码

src/io/io.go
func Copy(dst Writer, src Reader) (written int64, err error) {
  return copyBuffer(dst, src, nil)
}
复制代码

// src/io/io.go
func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
  // 如果源实现了 WriteTo 方法，则直接调用 WriteTo
  if wt, ok := src.(WriterTo); ok {
    return wt.WriteTo(dst)
  }
  // 同样的，如果目标实现了 ReaderFrom 方法，则直接调用 ReaderFrom
  if rt, ok := dst.(ReaderFrom); ok {
    return rt.ReadFrom(src)
  }
  // 如果 buf 为空，则创建 32KB 的 buf
  if buf == nil {
    size := 32 * 1024
    if l, ok := src.(*LimitedReader); ok && int64(size) > l.N {
      if l.N < 1 {
        size = 1
      } else {
        size = int(l.N)
      }
    }
    buf = make([]byte, size)
  }
  // 循环读取数据并写入
  for {
    nr, er := src.Read(buf)
    if nr > 0 {
      nw, ew := dst.Write(buf[0:nr])
      if nw < 0 || nr < nw {
        nw = 0
        if ew == nil {
          ew = errInvalidWrite
        }
      }
      written += int64(nw)
      if ew != nil {
        err = ew
        break
      }
      if nr != nw {
        err = ErrShortWrite
        break
      }
    }
    if er != nil {
      if er != EOF {
        err = er
      }
      break
    }
  }
  return written, err
}
复制代码

// ReadDir 读取指定目录中的所有目录和文件（不包括子目录）。
// 返回读取到的文件信息列表和遇到的错误，列表是经过排序的。
func ReadDir(dirname string) ([]os.FileInfo, error)
复制代码

package main
import (
  "fmt"
  "io/ioutil"
)
func main() {
  dirName := "../"
  fileInfos, _ := ioutil.ReadDir(dirName)
  fmt.Println(len(fileInfos))
  for i := 0; i < len(fileInfos); i++ {
    fmt.Printf("%T\n", fileInfos[i])
    fmt.Println(i, fileInfos[i].Name(), fileInfos[i].IsDir())
  }
}
复制代码

// ReadFile 读取文件中的所有数据，返回读取的数据和遇到的错误
// 如果读取成功，则 err 返回 nil，而不是 EOF
func ReadFile(filename string) ([]byte, error)
复制代码

package main
import (
  "fmt"
  "io/ioutil"
  "os"
)
func main() {
  data, err := ioutil.ReadFile("./test.txt")
  if err != nil {
    fmt.Println("read error")
    os.Exit(1)
  }
  fmt.Println(string(data))
}
复制代码

// WriteFile 向文件中写入数据，写入前会清空文件。
// 如果文件不存在，则会以指定的权限创建该文件。
// 返回遇到的错误。
func WriteFile(filename string, data []byte, perm os.FileMode) error
复制代码

package main
import (
  "fmt"
  "io/ioutil"
)
func main() {
  fileName := "./text.txt"
  s := "Hello AlwaysBeta"
  err := ioutil.WriteFile(fileName, []byte(s), 0777)
  fmt.Println(err)
}
复制代码

// TempFile 在 dir 目录中创建一个以 prefix 为前缀的临时文件，并将其以读
// 写模式打开。返回创建的文件对象和遇到的错误。
// 如果 dir 为空，则在默认的临时目录中创建文件（参见 os.TempDir），多次
// 调用会创建不同的临时文件，调用者可以通过 f.Name() 获取文件的完整路径。
// 调用本函数所创建的临时文件，应该由调用者自己删除。
func TempFile(dir, prefix string) (f *os.File, err error)
复制代码

package main
import (
  "fmt"
  "io/ioutil"
  "os"
)
func main() {
  f, err := ioutil.TempFile("./", "Test")
  if err != nil {
    fmt.Println(err)
  }
  defer os.Remove(f.Name()) // 用完删除
  fmt.Printf("%s\n", f.Name())
}
复制代码

// TempDir 功能同 TempFile，只不过创建的是目录，返回目录的完整路径。
func TempDir(dir, prefix string) (name string, err error)
复制代码

package main
import (
  "fmt"
  "io/ioutil"
  "os"
)
func main() {
  dir, err := ioutil.TempDir("./", "Test")
  if err != nil {
    fmt.Println(err)
  }
  defer os.Remove(dir) // 用完删除
  fmt.Printf("%s\n", dir)
}
复制代码

// NopCloser 将 r 包装为一个 ReadCloser 类型，但 Close 方法不做任何事情。
func NopCloser(r io.Reader) io.ReadCloser
复制代码

package main
import (
  "fmt"
  "io/ioutil"
  "reflect"
  "strings"
)
func main() {
  //返回 *strings.Reader
  reader := strings.NewReader("Hello AlwaysBeta")
  r := ioutil.NopCloser(reader)
  defer r.Close()
  fmt.Println(reflect.TypeOf(reader))
  data, _ := ioutil.ReadAll(reader)
  fmt.Println(string(data))
}
复制代码