"io"包提供了对I/O原语的基本接口。
本包的基本任务是包装这些原语已有的实现，使之成为共享的公共接口，
这些公共接口抽象出了泛用的函数并附加了一些相关的原语的操作。

Reader接口用于包装基本的读取方法。
type Reader interface {
	Read(p []byte) (n int, err error)
}

Writer接口用于包装基本的写入方法。
type Writer interface {
    Write(p []byte) (n int, err error)
}

Closer接口用于包装基本的关闭方法。
type Closer interface {
    Close() error
}

Seeker接口用于包装基本的移位方法。
type Seeker interface {
	Seek(offset int64, whence int) (int64, error)
}

Reader、Writer、Closer、Seeker四个基本接口的组合接口：
ReadWriter、ReadCloser、WriteCloser、ReadWriteCloser、
ReadSeeker、ReadSeekCloser、WriteSeeker、ReadWriteSeeker

ReaderFrom接口包装了基本的ReadFrom方法。
type ReaderFrom interface {
	ReadFrom(r Reader) (n int64, err error)
}

WriterTo接口包装了基本的WriteTo方法。
type WriterTo interface {
	WriteTo(w Writer) (n int64, err error)
}

ReaderAt接口包装了基本的ReadAt方法。
type ReaderAt interface {
	ReadAt(p []byte, off int64) (n int, err error)
}

WriterAt接口包装了基本的WriteAt方法。
type WriterAt interface {
	WriteAt(p []byte, off int64) (n int, err error)
}

ByteReader是基本的ReadByte方法的包装。
type ByteReader interface {
	ReadByte() (byte, error)
}

ByteScanner接口在基本的ReadByte方法之外还添加了UnreadByte方法。
type ByteScanner interface {
	ByteReader
	UnreadByte() error
}

ByteWriter是基本的WriteByte方法的包装。
type ByteWriter interface {
	WriteByte(c byte) error
}

RuneReader是基本的ReadRune方法的包装。
ReadRune读取单个utf-8编码的字符，返回该字符和它的字节长度。如果没有有效的字符，会返回错误。
type RuneReader interface {
	ReadRune() (r rune, size int, err error)
}

RuneScanner接口在基本的ReadRune方法之外还添加了UnreadRune方法。
type RuneScanner interface {
	RuneReader
	UnreadRune() error
}

StringWriter是基本的WriteString方法的包装。
type StringWriter interface {
	WriteString(s string) (n int, err error)
}

func WriteString(w Writer, s string) (n int, err error)
将字符串s的内容写入w中。如果w已经实现了WriteString方法，函数会直接调用该方法。

func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)
从r至少读取min字节数据填充进buf。函数返回写入的字节数和错误（如果没有读取足够的字节）。
只有没有读取到字节时才可能返回EOF；如果读取了有但不够的字节时遇到了EOF，函数会返回ErrUnexpectedEOF。
如果min比buf的长度还大，函数会返回ErrShortBuffer。只有返回值err为nil时，返回值n才会不小于min。

func ReadFull(r Reader, buf []byte) (n int, err error) {
	return ReadAtLeast(r, buf, len(buf))
}
从r精确地读取len(buf)字节数据填充进buf。

func Copy(dst Writer, src Reader) (written int64, err error)
将副本从src复制到dst，返回复制的字节数和遇到的第一个错误。成功时返回err为nil而不是EOF。
如果src实现WriterTo接口，则通过调用src.WriteTo（dst）来实现拷贝。
否则，如果dst实现ReaderFrom接口，则通过调用dst.ReadFrom（src）实现拷贝。

func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)
CopyBuffer与Copy相同，只是它通过提供的缓冲区（如果需要的话）进行分级，而不是分配临时缓冲区
如果src实现WriterTo或dst实现ReaderFrom，则不会使用buf执行复制。

func CopyN(dst Writer, src Reader, n int64) (written int64, err error)
从src拷贝n个字节数据到dst，直到在src上到达EOF或发生错误。返回复制的字节数和遇到的第一个错误。
只有err为nil时，written才会等于n。如果dst实现了ReaderFrom接口，本函数调用它实现拷贝。

func NopCloser(r Reader) ReadCloser
返回一个ReadCloser，其中包含一个no-op-Close方法，该方法包装提供的Reader。 

func ReadAll(r Reader) ([]byte, error)
从r读取，直到出现错误或EOF，并返回它读取的数据。成功的调用返回err为nil而不是EOF。

========== ========== ========== ========== ==========

"bufio"包实现了有缓冲的I/O。
它包装一个io.Reader或io.Writer接口对象，同时还提供了缓冲和一些文本I/O的帮助函数的对象。

func NewReaderSize(rd io.Reader, size int) *Reader
创建一个具有最少有size尺寸的缓冲、从r读取的*Reader。如果参数r已经是一个具有足够大缓冲的*Reader类型值，会返回r。

func NewReader(rd io.Reader) *Reader
创建一个具有默认大小(4096)缓冲、从r读取的*Reader。

func (b *Reader) Size() int
返回底层缓冲区的字节数。

func (b *Reader) Reset(r io.Reader)
丢弃缓冲中的数据，清除任何错误，将b重设为其下层从r读取数据。

func (b *Reader) Peek(n int) ([]byte, error)
返回输入流的下n个字节，而不会移动读取位置。返回的[]byte只在下一次调用读取操作前合法。
如果Peek返回的切片长度比n小，它也会返会一个错误说明原因。如果n比缓冲尺寸还大，返回的错误将是ErrBufferFull。

func (b *Reader) Discard(n int) (discarded int, err error)
跳过接下来的n个字节，返回丢弃的字节数。如果跳过的字节数少于n个，它还会返回一个错误。
如果0<=n<=b.Buffered()，则保证在不读取基础io.Reader的情况下放弃成功。

func (b *Reader) Read(p []byte) (n int, err error)
读取数据写入p。本方法返回写入p的字节数。
本方法一次调用最多会调用下层Reader接口一次Read方法，因此返回值n可能小于len(p)。
读取到达结尾时，返回值n将为0，err将为io.EOF。

func (b *Reader) ReadByte() (byte, error)
读取并返回一个字节。如果没有可用的数据，会返回错误。

func (b *Reader) UnreadByte() error
吐出最近一次读取操作读取的最后一个字节。（只能吐出最后一个，多次调用会出问题）

func (b *Reader) ReadRune() (r rune, size int, err error)
读取一个utf-8编码的unicode码值，返回该码值、其编码长度和可能的错误。
如果utf-8编码非法，读取位置只移动1字节，返回U+FFFD，返回值size为1而err为nil。
如果没有可用的数据，会返回错误。

func (b *Reader) UnreadRune() error
吐出最近一次ReadRune调用读取的unicode码值。
如果最近一次读取不是调用的ReadRune，会返回错误。（从这点看，UnreadRune比UnreadByte严格很多）

func (b *Reader) Buffered() int
返回缓冲中现有的可读取的字节数。

func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
读取直到第一次遇到delim字节，返回缓冲里的包含已读取的数据和delim字节的切片。该返回值只在下一次读取操作之前合法。
如果ReadSlice放在在读取到delim之前遇到了错误，它会返回在错误之前读取的数据在缓冲中的切片以及该错误（一般是io.EOF）。
如果在读取到delim之前缓冲就被写满了，ReadSlice失败并返回ErrBufferFull。

func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
ReadLine是一个低水平的行数据读取原语。ReadLine尝试返回一行数据，不包括行尾标志的字节。
如果行太长超过了缓冲，返回值isPrefix会被设为true，并返回行的前面一部分。
该行剩下的部分将在之后的调用中返回。返回值isPrefix会在返回该行最后一个片段时才设为false。
返回的文本不包含行尾的标志字节（"\r\n"或"\n"）。
如果输入流结束时没有行尾标志字节，方法不会出错，也不会指出这一情况。

func (b *Reader) ReadBytes(delim byte) ([]byte, error)
读取直到第一次遇到delim字节，返回一个包含已读取的数据和delim字节的切片。
如果ReadBytes方法在读取到delim之前遇到了错误，它会返回在错误之前读取的数据以及该错误（一般是io.EOF）。
当且仅当ReadBytes方法返回的切片不以delim结尾时，会返回一个非nil的错误。

func (b *Reader) ReadString(delim byte) (string, error)
读取直到第一次遇到delim字节，返回一个包含已读取的数据和delim字节的字符串。
如果ReadString方法在读取到delim之前遇到了错误，它会返回在错误之前读取的数据以及该错误（一般是io.EOF）。
当且仅当ReadString方法返回的切片不以delim结尾时，会返回一个非nil的错误。

func (b *Reader) WriteTo(w io.Writer) (n int64, err error)
WriteTo方法实现了io.WriterTo接口。

func NewWriterSize(w io.Writer, size int) *Writer
创建一个具有最少有size尺寸的缓冲、写入w的*Writer。如果参数w已经是一个具有足够大缓冲的*Writer类型值，会返回w。

func NewWriter(w io.Writer) *Writer
创建一个具有默认大小(4096)缓冲、写入w的*Writer。

func (b *Writer) Size() int
返回底层缓冲区的字节数。

func (b *Writer) Reset(w io.Writer)
丢弃缓冲中的数据，清除任何错误，将b重设为将其输出写入w。

func (b *Writer) Flush() error
将缓冲中的数据写入下层的io.Writer接口。

func (b *Writer) Available() int
返回缓冲区中未使用的字节数。

func (b *Writer) Buffered() int
返回缓冲中已使用的字节数。

func (b *Writer) Write(p []byte) (nn int, err error)
将p的内容写入缓冲。返回写入的字节数。如果返回值nn < len(p)，还会返回一个错误说明原因。

func (b *Writer) WriteByte(c byte) error
写入单个字节。

func (b *Writer) WriteRune(r rune) (size int, err error)
写入一个unicode码值（的utf-8编码），返回写入的字节数和可能的错误。

func (b *Writer) WriteString(s string) (int, error)
写入一个字符串。返回写入的字节数。如果返回值nn < len(s)，还会返回一个错误说明原因。

func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)
ReadFrom实现io.ReaderFrom。

func NewReadWriter(r *Reader, w *Writer) *ReadWriter
申请创建一个新的、将读写操作分派给r和w 的ReadWriter。

func NewScanner(r io.Reader) *Scanner
创建并返回一个从r读取数据的Scanner，默认的分割函数是ScanLines。

func (s *Scanner) Err() error
返回Scanner遇到的第一个非EOF的错误。

func (s *Scanner) Bytes() []byte
返回最近一次Scan调用生成的token。底层数组指向的数据可能会被下一次Scan的调用重写。

func (s *Scanner) Text() string
返回最近一次Scan调用生成的token，会申请创建一个字符串保存token并返回该字符串。

func (s *Scanner) Scan() bool
扫描位置移动到下一个token。当扫描因为抵达输入流结尾或者遇到错误而停止时，本方法会返回false。
在Scan方法返回false后，Err方法将返回扫描时遇到的任何错误；除非是io.EOF，否则Err会返回nil。

func (s *Scanner) Buffer(buf []byte, max int)
设置扫描时使用的初始缓冲区以及扫描期间可能分配的最大缓冲区大小。
最大令牌大小是max和cap(buf)中的较大者。如果最大值<=上限(buf)，扫描将仅使用此缓冲区，不进行分配。

type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)
SplitFunc类型代表用于对输出作词法分析的分割函数。

func (s *Scanner) Split(split SplitFunc)
设置该Scanner的分割函数。本方法必须在Scan之前调用。

func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error)
将每个字节作为一个token返回。

func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error)
将每个utf-8编码的unicode码值作为一个token返回。本函数返回的rune序列和range一个字符串的输出rune序列相同。

func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error)
将每一行文本去掉末尾的换行标记作为一个token返回。返回的行可以是空字符串。
换行标记为一个可选的回车后跟一个必选的换行符。最后一行即使没有换行符也会作为一个token返回。

func ScanWords(data []byte, atEOF bool) (advance int, token []byte, err error)
将空白（参见unicode.IsSpace）分隔的片段（去掉前后空白后）作为一个token返回。永远不会返回空字符串。