go语言之IO包详细总结

//读取到结尾错误
var EOF = errors.New("EOF")
//管道关闭的错误
var ErrClosedPipe = errors.New("io: read/write on closed pipe")
//多次调用reader都没有返回数据，一般来说就是封装的reader有问题
var ErrNoProgress = errors.New("multiple Read calls return no data or error")
//缓冲池不够大
var ErrShortBuffer = errors.New("short buffer")
//写的数据比提供的少
var ErrShortWrite = errors.New("short write")
//这个表示在没有读取对应的数据时候，没有读取完成返回的错误
var ErrUnexpectedEOF = errors.New("unexpected EOF")

//这个表示，将目标数据按照len(p)的字节长度，写到缓冲区p中
type Reader interface {
    Read(p []byte) (n int, err error)
}
//将len(p)字节数据从p写入目标数据位置，注意此时缓冲区p是由数据的
type Writer interface {
    Write(p []byte) (n int, err error)
}
//读取完，或者写完关闭掉
type Closer interface {
    Close() error
}
============================如下3个经常配合使用==============================
//偏移量，指的是鼠标的光标位置在哪里，offset表示正数向左偏移，负数表示向右偏移
//io.SeekStart开头进行偏移，io.SeekCurrent当前位置进行偏移，io.SeekEnd最后位置进行偏移
type Seeker interface {
    Seek(offset int64, whence int) (int64, error)
}
//从鼠标当前的位置进行写入
type WriterAt interface {
    WriteAt(p []byte, off int64) (n int, err error)
}
//从鼠标当前的位置进行读取
type ReaderAt interface {
    ReadAt(p []byte, off int64) (n int, err error)
}

//读取输入中的单个字节并返回，循环读取的时候，注意设置err=io.EOF
type ByteReader interface {
    ReadByte() (c byte, err error)
}
// UnreadByte() 就是将光标的偏移量保持不动，底层实际上执行了一个减一的操作
type ByteScanner interface {
    ByteReader
    UnreadByte() error
}
//举例
func main() {

	var s bytes.Buffer

	s.Write([]byte("haha"))
	bytebuf, _ := s.ReadByte()
	fmt.Println(string(bytebuf)) //第一次光标在h，打印h
	bytebuf, _ = s.ReadByte()
	fmt.Println(string(bytebuf)) //第二次光标的位置加一，打印a
	s.UnreadByte()               //第三次让光标的位置减一
	bytebuf, _ = s.ReadByte()    //然后在让光标的位置加一
	fmt.Println(string(bytebuf)) //等于还会打印a
	bytebuf, _ = s.ReadByte()
	fmt.Println(string(bytebuf)) //这个光标的位置加1，然后就会打印h
}

//读取单个utf-8编码的字符，返回该字符按以及该字符的字节长度
type RuneReader interface {
    ReadRune() (r rune, size int, err error)
}
type RuneScanner interface {
    RuneReader
    UnreadRune() error
}

type ByteWriter interface {
    WriteByte(c byte) error
}
//将目标的reader，读取到对应的buff里面
type ReaderFrom interface {
    ReadFrom(r Reader) (n int64, err error)
}
//向目标writer写入数据
type WriterTo interface {
    WriteTo(w Writer) (n int64, err error)
}
==========================实例=================================================
func main() {

	var buff bytes.Buffer
	var buff1 bytes.Buffer
	fp, err := os.OpenFile("E:/a.txt", os.O_RDWR, 6)
	if err != nil {
		fmt.Println("open err", err)
	}
	defer fp.Close()
	n,err:=buff.ReadFrom(fp)//这个代表将fp的内容读取到buff中
	fmt.Println(n)
	fmt.Println(string(buff.Bytes()))
	buff.WriteTo(&buff1) //这个代表将buff中的数据写到了buff1中
	fmt.Println(string(buff1.Bytes()))
}

官方解释:LimitedReader从R中读取数据，但限制可以读取的数据的量为最多N字节，每次调用Read方法都会更新N以标记剩余可以读取的字节数。
type LimitedReader struct {
    R   Reader // 底层Reader接口
    N   int64  // 剩余可读取字节数
}
func LimitReader(r Reader, n int64) Reader
func (l *LimitedReader) Read(p []byte) (n int, err error)
=============================实例=====================================
func main() {
	var buff bytes.Buffer //第一步创建一个buff
	buff.WriteString("hahaha") //第二步向里面写入六个字节
	LimitReader:=io.LimitReader(&buff,2)//创建一个limitreader
	p:=make([]byte,1024)  //创建一个字节切片，大小为1024
	n,_:=LimitReader.Read(p)//buff已两个字节，读取到切片p中
	fmt.Println(n)  //打印的数据 2
	fmt.Println(string(p[:n])) //打印的数据为ha
}

type SectionReader struct {
    // 内含隐藏或非导出字段
}
func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader
func (s *SectionReader) Size() int64
func (s *SectionReader) Read(p []byte) (n int, err error)
func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)
func (s *SectionReader) Seek(offset int64, whence int) (int64, error)
//===============================实战==================================
func main() {
	//a文件内容：abc1efg
	fp, err := os.OpenFile("E:/a.txt", os.O_RDWR, 6)
	if err != nil {
		fmt.Println("open err", err)
	}
	defer fp.Close()

	//这个代表从偏移为1的位置，读取3个数据结束 这个范围已经锁死，只能读取bc1
	SectionReader := io.NewSectionReader(fp, 1, 3)
	n := SectionReader.Size()
	fmt.Println(n)
	p := make([]byte, 1024)
	n1, _ := SectionReader.Read(p)
	fmt.Println(string(p[:n1])) //这个就是bc1

	n3, _ := SectionReader.Seek(2, io.SeekStart)//偏移两个位置，读取3个数据
	m := make([]byte, 1024)
	n4, _ := SectionReader.ReadAt(m, n3)
	fmt.Println(string(m[:n4]))//只能读取1
}

官方解释：Pipe创建一个同步的内存中的管道。它可以用于连接期望io.Reader的代码和期望io.Writer的代码。一端的读取对应另一端的写入，直接在两端拷贝数据，没有内部缓冲。可以安全的并行调用Read和Write或者Read/Write与Close方法。Close方法会在最后一次阻塞中的I/O操作结束后完成。并行调用Read或并行调用Write也是安全的：每一个独立的调用会依次进行。
func Pipe() (*PipeReader, *PipeWriter)
type PipeReader struct {
    // 内含隐藏或非导出字段
}
func (r *PipeReader) Read(data []byte) (n int, err error)
func (r *PipeReader) Close() error
func (r *PipeReader) CloseWithError(err error) error	
type PipeWriter struct {
    // 内含隐藏或非导出字段
}
func (w *PipeWriter) Write(data []byte) (n int, err error)
func (w *PipeWriter) Close() error
func (w *PipeWriter) CloseWithError(err error) error
//======================这个必须要在go程里面读写======================
func main() {
	buff1, buff2 := io.Pipe()
	p := make([]byte, 1024)
	for i := 0; i < 10; i++ {
		go buff2.Write([]byte("hahahhaha"+strconv.Itoa(i)))
	}
	for i := 0; i < 10; i++ {
		n, _ := buff1.Read(p)
		fmt.Println(string(p[:n]))
	}
	for{
		;
	}
}

func TeeReader(r Reader, w Writer) Reader
//=============================实战======================
func main() {
	var buff bytes.Buffer
	var buff1 bytes.Buffer
	buff1.Write([]byte("hahhaha"))
	buff.Write([]byte("xixixixixixixi"))
	p:=make([]byte,1024)
	//表示将buff1的内容追加到buff中，buff2存储的数据就是buff1写入的数据
	buff2:=io.TeeReader(&buff1,&buff)
	n,_:=buff2.Read(p)
	fmt.Println(string(p[:n]))//打印结果：hahhaha
	fmt.Println(string(buff.Bytes()))//打印结果是：xixixixixixixihahhaha
}

//为毛我测试的reader不能成功，writer可以同时写，但是读的不行
func MultiReader(readers ...Reader) Reader
func MultiWriter(writers ...Writer) Writer

//将src的数据拷贝到dst
func Copy(dst Writer, src Reader) (written int64, err error)
//将src的n个字节的数据拷贝到dst
func CopyN(dst Writer, src Reader, n int64) (written int64, err error)

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

//从r精确地读取len(buf)字节数据填充进buf，这个比较常用
func ReadFull(r Reader, buf []byte) (n int, err error)

//将字符串写道w中
func WriteString(w Writer, s string) (n int, err error)