为什么要避免在 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，而不是 EOFfunc 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))}