关于golang:Go标准库源码阅读之-io

io 规范库中外围是要了解 io.Reader 和 io.Writer 两个接口

// Reader 其实就是封装了下 Read 函数
// Read 函数冀望读取 len(p) bytes 到 p 中，并返回理论读取的长度，即便数据有余 len(p) 
// 也会立刻返回；只有读取到的数据长度大于 0，就要返回 err = nil; 如果没有可读取的数据，则返回 0, EOF; Read 不容许呈现 0,nil 这样的返回值
type Reader interface {Read(p []byte) (n int, err error)
}

// Reader 其实是封装了下 Writer 函数
// Write 就是将 p 中保留的数据写入到内部结构体，并返回理论写入的数据
// 同 Read 一样，返回值不能是 0, nil; 并且 Write 函数中不能扭转原始数据，哪怕长期扭转也不容许
type Writer interface {Write(p []byte) (n int, err error)
}

围绕 io.Reader/Writer，有几个罕用的实现：

• net.Conn, os.Stdin, os.File: 网络、规范输入输出、文件的流读取
• strings.Reader: 把字符串形象成 Reader
• bytes.Reader: 把 []byte 形象成 Reader
• bytes.Buffer: 把 []byte 形象成 Reader 和 Writer

• bufio.Reader/Writer: 形象成带缓冲的流读取（比方按行读写）
  以 strings.Reader 源码举例剖析：

  // 当然 string.Reader 不仅仅实现了 io.Reader 接口，还反对很多
  // A Reader implements the io.Reader, io.ReaderAt, io.ByteReader, io.ByteScanner,
  // io.RuneReader, io.RuneScanner, io.Seeker, and io.WriterTo interfaces by reading
  // from a string.
  // The zero value for Reader operates like a Reader of an empty string.
  type Reader struct {
    s        string
    i        int64 // 指向当初读取的地位
    prevRune int   // index of previous rune; or < 0
  }
  
  // Read implements the io.Reader interface.
  func (r *Reader) Read(b []byte) (n int, err error) {
    // 曾经读到字符串开端，间接返回 io.EOF
    if r.i >= int64(len(r.s)) {return 0, io.EOF}
     // 因为是依照 byte 读的，所以这个标记位无意义
    r.prevRune = -1
    // 读取数据
    n = copy(b, r.s[r.i:])
    // 挪动读取地位指针，向后偏移理论读取的量
    r.i += int64(n)
    return
  }

  当很多 io 相干的操作，比方读写文件、读写网络数据等场景都实现了 Write、Read 接口，那么很多跨 io 的操作就能够无缝实现，比方将网络读取的数据间接写入文件

  // Copy 从 src 拷贝数据到 dst，直到遇到 EOF，或者产生谬误
  // 如果 src 中实现了 WriterTo 接口，则调用 src.WriteTo(dst)
  // 如果 dst 中实现了 ReaderFrom 接口，则调用 dst.ReadFrom(src)
  func Copy(dst Writer, src Reader) (written int64, err error) {return copyBuffer(dst, src, nil)
  }
  // 这个函数与 Copy 的区别就是须要咱们本人提供 buf 缓冲区
  func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {if buf != nil && len(buf) == 0 {panic("empty buffer in CopyBuffer")
    }
    return copyBuffer(dst, src, buf)
  }
  
  // copyBuffer 是 Copy 和 CopyBuffer 的具体实现
  func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
    // 如果 Reader 实现了 WriteTo 办法, 则间接调用它是先数据拷贝
    if wt, ok := src.(WriterTo); ok {return wt.WriteTo(dst)
    }
    // 如果 Writer 实现了 ReaderFrom 办法, 则间接调用它是先数据拷贝
    if rt, ok := dst.(ReaderFrom); ok {return rt.ReadFrom(src)
    }
    // 如果没有提供数据缓冲去，则调配一段长期缓冲区
    if buf == nil {
        size := 32 * 1024
        // LimitedReader 是 io 中实现的一个有读取长度限度的构造体，所以如果 Read 中实现了该构造体，则应用其定义的长度
        if l, ok := src.(*LimitedReader); ok && int64(size) > l.N {
            if l.N < 1 {size = 1} else {size = int(l.N)
            }
        }
        buf = make([]byte, size)
    }
    for {nr, er := src.Read(buf)
        if nr > 0 {nw, ew := dst.Write(buf[0:nr])
            if nw < 0 || nr < nw {
                nw = 0
                if ew == nil {ew = errInvalidWrite}
            }
            written += int64(nw)
            if ew != nil {
                err = ew
                break
            }
            // 如果写入的数据无奈全副写，则返回 ErrShortWrite 谬误
            if nr != nw {
                err = ErrShortWrite
                break
            }
        }
        if er != nil {
            if er != EOF {err = er}
            break
        }
    }
    // 返回 Copy 的数据长度
    return written, err
  }