io

 

 

 接口实现

 

type LimitedReader struct {
    R Reader // underlying reader
    N int64  // max bytes remaining
}

func (l *LimitedReader) Read(p []byte) (n int, err error) {
　　　　// 返回的总数据总总会收到限制，无论该方法调用多少次；限制由字段N指明，单位字节
    if l.N <= 0 {
        return 0, EOF
    }
    if int64(len(p)) > l.N {
        p = p[0:l.N]
    }
    n, err = l.R.Read(p)
    l.N -= int64(n)
    return
}

 

//起始位置和末尾位置，需要在它被初始化的时候就指明，并且之后无法变更。
// 该类型值的行为与切片有些类似，它只会对外暴露在其窗口之中的那些数据。

// section 翻译   ：截断

type SectionReader struct {
    r     io.ReaderAt //包装io.ReaderAt类型,限制它的Read方法,只能够读取原始数据中的部分
    base  int64
    off   int64
    limit int64
}

func (s *SectionReader) Read(p []byte) (n int, err error) {
    if s.off >= s.limit {
        return 0, io.EOF
    }
    if max := s.limit - s.off; int64(len(p)) > max {
        p = p[0:max]
    }
    n, err = s.r.ReadAt(p, s.off)
    s.off += int64(n)
    return
}

var errWhence = errors.New("Seek: invalid whence")
var errOffset = errors.New("Seek: invalid offset")

func (s *SectionReader) Seek(offset int64, whence int) (int64, error) {
    switch whence {
    default:
        return 0, errWhence
    case io.SeekStart:
        offset += s.base
    case io.SeekCurrent:
        offset += s.off
    case io.SeekEnd:
        offset += s.limit
    }
    if offset < s.base {
        return 0, errOffset
    }
    s.off = offset
    return offset - s.base, nil
}

func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error) {
    if off < 0 || off >= s.limit-s.base {
        return 0, io.EOF
    }
    off += s.base
    if max := s.limit - off; int64(len(p)) > max {
        p = p[0:max]
        n, err = s.r.ReadAt(p, off)
        if err == nil {
            err = io.EOF
        }
        return n, err
    }
    return s.r.ReadAt(p, off)
}

// Size returns the size of the section in bytes.
func (s *SectionReader) Size() int64 { return s.limit - s.base }

其他实现

func TeeReader(r Reader, w Writer) Reader {
    return &teeReader{r, w}
}

type teeReader struct {
    r Reader
    w Writer
}

func (t *teeReader) Read(p []byte) (n int, err error) {
// 将reader的数据写到writer
    n, err = t.r.Read(p)
    if n > 0 {
        if n, err := t.w.Write(p[:n]); err != nil {
            return n, err
        }
    }
    return
}

io.multiReader：此类型也是一个包级私有的数据类型。类似的，io包中有一个名为MultiReader的函数，它可以接受若干个io.Reader类型的参数值，并返回一个实际类型为io.multiReader的结果值。

当这个结果值的Read方法被调用时，它会顺序地从前面那些io.Reader类型的参数值中读取数据。因此，我们也可以称之为多对象读取器。

io.pipe：此类型为一个包级私有的数据类型，它比上述类型都要复杂得多。它不但实现了io.Reader接口，而且还实现了io.Writer接口。

实际上，io.PipeReader类型和io.PipeWriter类型拥有的所有指针方法都是以它为基础的。这些方法都只是代理了io.pipe类型值所拥有的某一个方法而已。

又因为io.Pipe函数会返回这两个类型的指针值并分别把它们作为其生成的同步内存管道的两端，所以可以说，*io.pipe类型就是io包提供的同步内存管道的核心实现。

io.PipeReader：此类型可以被视为io.pipe类型的代理类型。它代理了后者的一部分功能，并基于后者实现了io.ReadCloser接口。同时，它还定义了同步内存管道的读取端。

 

数据段读取器io.SectionReader、
作为同步内存管道核心实现的io.pipe类型，
用于数据拷贝的io.CopyN函数