Golang中输入和输出操作使用原语实现，这些原语将数据模拟称为可读或可写的字节流。为此，Golang的io包提供了io.Reader和io.Writer接口，分别用于数据的输入和输出。

io

Golang的io包提供了对I/O原语的基本接口，包装了原语的已有实现，使之成为共享的公共接口，抽象出泛用的函数并附加了相关的原语操作。这些接口和原语是对底层实现完全不同的低水平操作的包装，除非得到其它方面的通知，客户端不应该假设它们是并发执行安全的。

io.EOF

• EOF是End-Of-File的缩写，根据Go惯例大写字母缩写表示常量，不过io.EOF被定义成了变量。
• io.EOF是io包中的一个变量，表示文件结束的错误。

1package io23var EOF = errors.New("EOF")

• io.EOF是Go中最重要的错误变量，用于表示输入流的结尾，因为每个文件都有一个结尾，所以io.EOF很多时候并不能算是一个错误，更重要是表示输入流结束了。

var EOF = errors.New("EOF")

io.Reader

• io.Reader表示一个读取器，将数据从某个资源读取到传输缓冲区。在缓冲区中，数据可以被流式传输和使用。

io.Reader

• 对于要用作读取器的类型，必须实现io.Reader接口的唯一方法Read(p []byte)。只要实现了Read(p []byte)就是一个读取器

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

• Read()方法具有两个返回值，若资源内容全部读取完毕，应该返回io.EOF错误。

利用io.Reader可以实现流式数据传输，Reader方法内部是被循环调用的，每次迭代，会从数据源读取一块数据放入缓冲区p中，直到返回io.EOF错误时停止。

例如：创建字符串读取器，流式地按字节读取。

str := "clear is better than clever"
//创建字符串读取器
reader := strings.NewReader(str)
//字节缓存区
buf := make([]byte, 4)
//循环读取
for{//读取到缓存区n,err := reader.Read(buf)if err!=nil{//读取结束if err!=io.EOF{fmt.Println("EOF:", n)break}fmt.Println(err)os.Exit(1)}result := string(buf[:n])fmt.Println(n, result)
}

4 clea
4 r is
4  bet
4 ter 
4 than
4  cle
3 ver
EOF

例如：实现从流中过滤掉非字母字符

//过滤函数
func alpha(c byte) byte{if (c>='a'&&c<='z') || (c>='A'&&c<='Z'){return c}return 0
}
type AlphaReader struct{src string //资源i int//当前读取的位置
}
func NewAlphaReader(src string) *AlphaReader{return &AlphaReader{src:src}
}
func (r *AlphaReader) Read(p []byte) (int,error){//判断是否已经读取到结尾if r.i >= len(r.src){return 0, io.EOF}//剩余未读取长度x := len(r.src) - r.i//缓存区填满大小bound := 0//判断剩余长度是否超过缓存区大小if x >= len(p){//完全填满缓冲区bound = len(p)}else if x < len(p){//缓存区无法补满bound = x}//创建缓存区buf := make([]byte, bound)//迭代读取i := 0for bound > i {//每次读取一个字节char := r.src[r.i]//执行过滤函数if c := alpha(char); c!=0{buf[i] = c}i++r.i++}//将缓存内容赋值到copy(p, buf)return i,nil
}

测试

str := "Hello! It's 9am, where is the sun?"buf := make([]byte, 4)
reader := NewAlphaReader(str)
for {n,err := reader.Read(buf)if err==io.EOF{break}data := string(buf[:n])fmt.Print(data)
}

• 组合多个Reader可重用和屏蔽下层实现的复杂度

标准库已经实现了多个Reader，可使用一个Reader作为另一个Reader的实现是一种常见用法，可让一个Reader重用另一个Reader的逻辑。

例如：修改AlphaReader以接受io.Reader作为其源

//过滤函数
func alpha(c byte) byte{if (c>='a'&&c<='z') || (c>='A'&&c<='Z'){return c}return 0
}
type AlphaReader struct{reader io.Reader//组合标准读取器
}
func NewAlphaReader(reader io.Reader) *AlphaReader{return &AlphaReader{reader:reader}
}
func (r *AlphaReader) Read(p []byte) (int,error){n,err := r.reader.Read(p)if err!=nil{return n,err}buf := make([]byte, n)for i:=0; i<n; i++{char := alpha(p[i])if char != 0{buf[i] = char}}copy(p, buf)return n,nil
}

测试

str := "Hello! It's 9am, where is the sun?"
reader := strings.NewReader(str)buf := make([]byte, 4)
r := NewAlphaReader(reader)
for {n,err := r.Read(buf)if err==io.EOF{break}data := string(buf[:n])fmt.Print(data)
}

例如：与os.File结束过滤掉文件中的非字母字符

$ vim ./test.txt
Hello! It's 9am, where is the sun?

file,err := os.Open("./test.txt")
if err!=nil{fmt.Println(err)os.Exit(1)
}
defer file.Close()r := NewAlphaReader(file)
buf := make([]byte, 4)
for {n,err := r.Read(buf)if err==io.EOF{break}data := string(buf[:n])fmt.Print(data)
}

io.Writer

• io.Writer表示一个编写器，从缓存区读取数据，并将数据写入目标资源。

io.Writer

• 对于要作为编写器的类型必须实现io.Writer接口唯一的方法Write(p []byte)，只要实现了Write(p []byte)就是一个编写器。

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

• Write()方法具有两个返回值，一个是写入到目标资源的字节数，一个是发生错误时的错误。

例如：使用bytes.Buffer类型作为io.Writer将数据写入内存缓存区

proverbs := []string{"many hands make light work","measure for measure","murder will out","never say die",
}var writer bytes.Buffer
for _,p := range proverbs{n,err := writer.Write([]byte(p))if err!=nil{fmt.Println(err)os.Exit(1)}if n != len(p){fmt.Println("failed to write data")os.Exit(1)}
}
result := writer.String()
fmt.Println(result)

例如：实现自定义的io.Writer将其内容作为字节序列写入通道

//ChanWriter 通道写入器
type ChanWriter struct{ch chan byte//目标资源
}
//NewChanWriter 创建通道写入器
func NewChanWriter() *ChanWriter{return &ChanWriter{ch:make(chan byte, 1024)}
}
//Chan 获取目标资源
func (w *ChanWriter) Chan() <-chan byte{return w.ch
}
//Close 关闭目标资源
func (w *ChanWriter) Close(){close(w.ch)
}
//Write 写入目标资源
func (w *ChanWriter) Write(p []byte) (int, error){n := 0//遍历输入数据按字节写入目标资源for _,b := range p{w.ch<-bn++}return n,nil
}

测试

writer := NewChanWriter()go func(){defer writer.Close()writer.Write([]byte("money can talk"))
}()for char := range writer.Chan(){fmt.Printf("%c\n", char)
}

io.Closer

• Closer是包装基本Close()方法的接口用于关闭数据流，第一次调用后Closer的行为是未定义的。
• 文件、归档(压缩包)、数据库连接、Socket等均需手动关闭的资源都实现了Closer接口。
• 编程中经常会将Close方法的调用放在defer语句中

type Closer interface{Close() error //关闭数据流
}

例如：

file,err := os.Open("test.txt")
if err!=nil{}
defer file.Close()

io.ReadCloser

• response.Body的类型为io.ReadCloser

io.WriteCloser

io.ReadWriteCloser