go语言标准文档库中文版 go语言常用标准库

在Go语言中I/O操作的内置库有很多种，比如:io库，os库，ioutil库，bytes库，strings库等等。

io.Reader/Writer

Go语言里使用io.Reader和io.Writer两个 interface 来抽象I/O，他们的定义如下。

type Reader interface {
 Read(p []byte) (n int, err error)
}
 
type Writer interface {
 Write(p []byte) (n int, err error)
}

io.Reader 接口代表一个可以从中读取字节流的实体，而io.Writer则代表一个可以向其写入字节流的实体。

io.Reader/Writer 常用的几种实现

• net.Conn:表示网络连接
• os.Stdin,os.Stdout,os.Stderr:标准输入，输出和错误
• os.File:网络,标准输入输出，文件的流读取
• strings.Reader:字符串抽象成io.Reader的实现
• bytes.Reader:[]byte抽象成io.Reader的实现
• byte.Buffer:[]byte抽象成io.Reader和io.Writer的实现
• bufio.Reader/Writer:带缓冲的流读取和写入(比如按行读写)

除了这几种实现外常用的还有ioutil工具库包含了很多IO工具函数，编码相关的内置库encoding/base64、encoding/binary等也是通过 io.Reader 和 io.Writer 实现各自的编码功能的。

这些常用实现和工具库与io.Reader和io.Writer间的关系可以用下图表示。

go文件方法继承 – 源码

每种I/O库的使用场景

io库

io库属于底层接口定义库。它的作用主要是定义个I/O的基本接口和基本常量，并解释这些接口的功能。在实际编写代码做I\O操作时，这个库一般只用来调用它的常量和接口定义，比如用io.EOF判断是否已经读取完，用io.Reader做变量的类型声明。

// 字节流读取完后，会返回io.EOF这个error
for {
 n, err := r.Read(buf)
 fmt.Println(n, err, buf[:n])
 if err == io.EOF {
  break
 }
}

os库

os库主要是处理操作系统操作的，它作为Go程序和操作系统交互的桥梁。创建文件，打开或者关闭文件，Socke等等操作都是和操作系统挂钩的，所以都通过os库来执行。这个库经常和ioutil,bufio等配合使用

读文件 – 使用

//os.OpenFile
f, _ := os.OpenFile("/etc/hosts", os.O_RDONLY, 0600)
buf := make([]byte, 128)
n, _ := f.Read(buf)
fmt.Println(string(buf[:n]))

//os.Open - 使用数组
f, _ := os.Open("/etc/hosts")
var buf [128]byte
n, _ := f.Read(buf[:])
fmt.Println(string(buf[:n]))


//os.Open - 直接初始化切片
f, err := os.Open("/etc/hosts")
buf := make([]byte, 5)
n, err := f.Read(buf)
fmt.Println(string(buf[:n]))

//f.Read读一个完整的文件
f, _ := os.Open("/etc/hosts")
buf := make([]byte, 128)
for {
    n, err := f.Read(buf)
    fmt.Println(string(buf[:n]))
    if err==io.EOF{
        break
    }
}

//ioutil.ReadFile
buf, _ := ioutil.ReadFile("/etc/hosts")
fmt.Println(string(buf))

//ioutil.ReadAll
f, _ := os.OpenFile("/etc/hosts", os.O_RDONLY, 0600)
buf, _ := ioutil.ReadAll(f)
fmt.Println(string(buf))

// bufio.NewReader
r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
buf, _ := ioutil.ReadAll(r)
fmt.Println(string(buf))

ioutil库

ioutil库是一个工具包，它提供了很多实用的IO工具函数，例如ReadAll，ReadFile，WriteFile，ReadDir。唯一需要注意的是它们都是一次性读取和一次性写入，所以使用时，尤其是把数据从文件里一次性读取时需要注意文件的大小。

读出文件中的所有内容

func readByFile() {
  data, err := ioutil.ReadFile( "./file/test.txt")
  if err != nil {
    log.Fatal("err:", err)
    return
  }
  fmt.Println("data", string(data)) 
}

将数据一次性写入文件

func writeFile() {
  err := ioutil.WriteFile("./file/write_test.txt", []byte("hello world!"), 0644)
  if err != nil {
    panic(err)
    return
  }
}

bufio库

bufio，可以理解为在io库的基础上额外封装加了一个缓存层，它提供了很多按行进行读取的函数，从io库的按字节读写变为按行读写对写代码来说还是方便了不少。

func readBigFile(filePath string) error {
  f, err := os.Open(filePath)
  defer f.Close()
 
  if err != nil {
    log.Fatal(err)
    return err
  }
 
  buf := bufio.NewReader(f)
  count := 0
  // 循环中打印前100行内容
  for {
    count += 1
    line, err := buf.ReadString('\n')
    line = strings.TrimSpace(line)
    if err != nil {
      return err
    }
    fmt.Println("line", line)
 
    if count > 100 {
      break
    }
  }
  return nil
}

• ReadLine和ReadString方法:buf.ReadLine()，buf.ReadString(“\n”)都是按行读，只不过ReadLine读出来的是[]byte,后者直接读出了string，最终他们底层调用的都是ReadSlice方法。

bytes和strings库

bytes和strings库里的bytes.Reader和string.Reader，它们都实现了io.Reader接口，也都提供了NewReader方法用来从[]byte或者string类型的变量直接构建出相应的Reader实现。

r := strings.NewReader("abcde")
// 或者是 bytes.NewReader([]byte("abcde"))
buf := make([]byte, 4)
for {
 n, err := r.Read(buf)
 fmt.Println(n, err, buf[:n])
 if err == io.EOF {
  break
 }
}

另外一个区别是bytes库有Buffer的功能，而strings库则没有

var buf bytes.Buffer
fmt.Fprintf(&buf, "Size: %d MB.", 85)
s := buf.String()) // s == "Size: 85 MB."

总结

关于io.Reader和io.Writer接口，可以简单的理解为读源和写源。也就是说，只要实现了Reader中的Read方法，这个东西就可以作为读源，里面可以包含数据，被我们读取。Writer也是如此