包IO提供I/O原语的基本接口。它的主要任务是包装这些原语的现有实现
1.Reader读取器
Reader是一个包裹基本读方法的接口,Read读取len(p)个bytes到p中，返回值n代表读取到的bytes数，值范围为大于等于0小于等于len(p).err为读取过程遇到的错误。即使read返回n<len（p），它也可以在调用期间使用p的所有部分作为临时空间。read通常返回可用的内容，而不是等待更多内容。
该接口只有Read一个方法，任何实现了该方法的类型都可以说是实现了读取器的功能。在参数类型为Reader时，都可以当做Reader类型传入。
Read方法参数为一个字节切片，数据读取，写入到该切片中，返回值类型为一个int类型，标识读取到的字节数，err标识读取过程中遇到的任何异常，当读取结束后，err返回值为io.EOF.该值标识读取内容结束，不能作为一般的异常处理。
type Reader interface {
Read(p []byte) (n int, err error)
}
2.Writer
Writer是包裹了基本写方法的接口。
Write从p中写len(p)个字节到底层的数据流，返回值n代表成功写入的bytes数，值范围为0<=n<=len(p),err代表写时遇到的错误。Write必须返回一个非空的错误，如果n<len(p),Write不能修改参数切片
type Writer interface {
Write(p []byte) (n int, err error)
}
types.Buffer类型实现了Write方法。
// Write appends the contents of p to the buffer, growing the buffer as
// needed. The return value n is the length of p; err is always nil. If the
// buffer becomes too large, Write will panic with ErrTooLarge.
func (b *Buffer) Write(p []byte) (n int, err error) {
b.lastRead = opInvalid
m, ok := b.tryGrowByReslice(len(p))
if !ok {
m = b.grow(len(p))
}
return copy(b.buf[m:], p), nil
}
package main
import (
"bytes"
"fmt"
"os"
)
func main() {
mircors := []string{
"Micro为构建微服务提供了一些基本模板，",
"目标就是要让开发分布式系统尽可能地简化。",
"因为微服务自身就是一个结构，",
"所以micro希望通过工具在逻辑层面上进行职责分离。",
}
var writer bytes.Buffer
for _, m := range mircors {
n, err := writer.Write([]byte(m))
if err != nil {
fmt.Println(err)
os.Exit(1)
}
if n != len(m) {
fmt.Println("write data error")
os.Exit(1)
}
}
fmt.Println(writer.String())
}
3.ReadWriter
// ReadWriter is the interface that groups the basic Read and Write methods.
type ReadWriter interface {
Reader
Writer
}
4.ReaderFrom
ReadFrom从r读取数据直到遇到EOF或者error.
type ReaderFrom interface {
ReadFrom(r Reader) (n int64, err error)
}
5.WriterTo
WriteTo向w中写数据，直到没有更多的数据可写或者遇到错误。
type WriterTo interface {
WriteTo(w Writer) (n int64, err error)
}
6.ReaderAt
ReadAt读取len(p)个字节到p从输入源的off偏移量开始。返回读取到的字节数和遇到的任何错误。如果ReadAt返回的n<len(p),同时将返回一个非空的错误，解释了为什么返回的字节数少，在这种层面上，ReadAt要严于Read.如果n=len(p), err == EOF或者err==nil.
type ReaderAt interface {
ReadAt(p []byte, off int64) (n int, err error)
}
7.WriterAt
WriterAt将len(p)个字节从p中写入到数据流中，写入时从偏移量off开始。返回写入的字节数和任何遇到错误。如果n<len(p),返回的err非空。
type WriterAt interface {
WriteAt(p []byte, off int64) (n int, err error)
}
8.Copy
从src中复制数据到dst直到在src中遇到EOF,或者产生错误。返回复制的bytes数量，和复制中遇到的错误。
一个成功的复制，返回的err==nil,而不是err==EOF.因为Copy被定义为从src中读取直到EOF.它并不会把EOF当做一个错误来对待。如果src实现了WriterTo接口，copy通过调用src.WriteTo(dst)来实现。否则，如果dst实现了ReaderFrom接口，copy通过调用dst.ReadFrom(src)来实现。
func Copy(dst Writer, src Reader) (written int64, err error) {
return copyBuffer(dst, src, nil)
}
示例：
package main
import (
"fmt"
"io/ioutil"
"strings"
"os"
"io"
)
func main(){
content, err := ioutil.ReadFile("./demo.go")
if err != nil {
fmt.Println(err)
}
fmt.Printf("file content: %s", content)
r := strings.NewReader("Hello World!")
n, err := io.Copy(os.Stdout, r)
fmt.Printf("\n%d, %v", n, err) //12, <nil>
}
9.StringWriter
将字符串内容写到w中，接受一个字节切片，如果w实现了StringWriter接口，则直接调用，调用w.Write方法。
type StringWriter interface {
WriteString(s string) (n int, err error)
}
func WriteString(w Writer, s string) (n int, err error) {
if sw, ok := w.(StringWriter); ok {
return sw.WriteString(s)
}
return w.Write([]byte(s))
}
示例：
nstr, errstr := io.WriteString(os.Stdout, "Hello world")
fmt.Printf("\n%d, %v", nstr, errstr)
