Go的io/ioutil

WriteString

// WriteString
// WriteString 将字符串 s 写入到 w 中,返回写入的字节数和写入过程中遇到的任何错误
// 如果 w 实现了 WriteString 方法,则调用 w 的 WriteString 方法将 s 写入 w 中
// 否则，将 s 转换为 []byte,然后调用 w.Write 方法将数据写入 w 中
// func WriteString(w Writer, s string) (n int, err error)
 
func main() {
    // os.Stdout 实现了 Writer 接口
    io.WriteString(os.Stdout, "Hello World!")
    // Hello World!
}

ReadAtLeast

// ReadAtLeast 从 r 中读取数据到 buf 中，要求至少读取 min 个字节
// 返回读取的字节数 n 和读取过程中遇到的任何错误
// 如果 n < min，则 err 返回 ErrUnexpectedEOF
// 如果 r 中无可读数据，则 err 返回 EOF
// 如果 min 大于 len(buf)，则 err 返回 ErrShortBuffer
// 只有当 n >= min 时 err 才返回 nil
// func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)
 
func main() {
    r := strings.NewReader("Hello World!")
    b := make([]byte, 32)
    n, err := io.ReadAtLeast(r, b, 20)
    fmt.Printf("%s\n%d, %v", b, n, err)
    // Hello World!
    // 12, unexpected EOF
}

ReadFull

// ReadFull 的功能和 ReadAtLeast 一样，只不过 min = len(buf)，
// 其中要求最少读取的字节数目是len(buf)，当r中数据少于len(buf)时便会报错
// func ReadFull(r Reader, buf []byte) (n int, err error)
 
func main() {
    r := strings.NewReader("Hello World!")
    b := make([]byte, 32)
    n, err := io.ReadFull(r, b)
    fmt.Printf("%s\n%d, %v", b, n, err)
    // Hello World!
    // 12, unexpected EOF
}

CopyN 

// CopyN 从 src 中复制 n 个字节的数据到 dst 中
// 它返回复制的字节数 written 和复制过程中遇到的任何错误
// 只有当 written = n 时，err 才返回 nil
// 如果 dst 实现了 ReadFrom 方法，则调用 ReadFrom 来执行复制操作
// func CopyN(dst Writer, src Reader, n int64) (written int64, err error)
 
func main() {
    r := strings.NewReader("Hello World!")
    n, err := io.CopyN(os.Stdout, r, 20)
    fmt.Printf("\n%d, %v", n, err)
    // Hello World!
    // 12, EOF
}

Copy 

// Copy 从 src 中复制数据到 dst 中，直到所有数据复制完毕
// 返回复制过程中遇到的任何错误
// 如果数据复制完毕，则 err 返回 nil，而不是 EOF
// 如果 dst 实现了 ReadeFrom 方法，则调用 dst.ReadeFrom(src) 复制数据
// 如果 src 实现了 WriteTo 方法，则调用 src.WriteTo(dst) 复制数据
func Copy(dst Writer, src Reader) (written int64, err error)
 
func main() {
    r := strings.NewReader("Hello World!")
    n, err := io.Copy(os.Stdout, r)
    fmt.Printf("\n%d, %v", n, err)
    // Hello World!
    // 12, <nil>
}

LimitReader 

// LimitReader 覆盖了 r 的 Read 方法
// 使 r 只能读取 n 个字节的数据，读取完毕后返回 EOF
// func LimitReader(r Reader, n int64) Reader
// LimitedReader 结构用来实现 LimitReader 的功能
// type LimitedReader struct
 
func main() {
    r := strings.NewReader("Hello World!")
    lr := io.LimitReader(r, 5)
    n, err := io.CopyN(os.Stdout, lr, 20)
    fmt.Printf("\n%d, %v", n, err)
    // Hello
    // 5, EOF
}

NewSectionReader 

// NewSectionReader 封装 r，并返回 SectionReader 类型的对象
// 使 r 只能从 off 的位置读取 n 个字节的数据，读取完毕后返回 EOF
// func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader
 
// SectionReader 结构用来实现 NewSectionReader 的功能
// SectionReader 实现了 Read、Seek、ReadAt、Size 方法
// type SectionReader struct
 
// Size 返回 s 中被限制读取的字节数
// func (s *SectionReader) Size()
 
func main() {
    r := strings.NewReader("Hello World!")
    sr := io.NewSectionReader(r, 0, 5)
    n, err := io.CopyN(os.Stdout, sr, 20)
    fmt.Printf("\n%d, %v", n, err)
    fmt.Printf("\n%d", sr.Size())
    // World
    // 5, EOF
    // 5
}

TeeReader 

// TeeReader 覆盖了 r 的 Read 方法
// 使 r 在读取数据的同时，自动向 w 中写入数据
// 所有写入时遇到的错误都被作为 err 返回值
// func TeeReader(r Reader, w Writer) Reader
 
func main() {
    r := strings.NewReader("Hello World!")
    tr := io.TeeReader(r, os.Stdout)
    b := make([]byte, 32)
    tr.Read(b)
    // World World!
}