byte.Reader 和 strings.Reader 代码阅

type Reader struct {
    s         []byte
    i         int64    // current reading index
    prevRune  int      // index of previous rune; or < 0
}

创建

func NewReader(b []byte) *Reader { return &Reader{b, 0, -1} }
func (r *Reader) Reset(b []byte) { *r = Reader{b, 0, -1} }

Len

返回剩下还没有读取的

func (r *Reader) Len() int {
    if r.i >= int64(len(r.s)) {
        return 0
    }
    return int(int64(len(r.s)) - r.i)
}

Size

func (r *Reader) Size() int64 { return int64(len(r.s)) }

实现 io.Reader 接口

func (r *Reader) Read(b []byte) (n int, err error) {
    if r.i >= int64(len(r.s)) {
        return 0, io.EOF
    }
    
    r.prevRune = -1
    n = copy(b, r.s[r.i:])
    r.i += int64(n)

    return
}

实现 io.ReaderAt 接口

func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) {
    // cannot modify state - see io.ReaderAt
    if off < 0 {
        return 0, errors.New("bytes.Reader.ReadAt: negative offset")
    }
    if off >= int64(len(r.s)) {
        return 0, io.EOF
    }
    n = copy(b, r.s[off:])
    if n < len(b) {
        err = io.EOF
    }
    return
}

实现 io.ByteReader 接口

func (r *Reader) ReadByte() (byte, error) {
    r.prevRune = -1
    if r.i >= int64(len(r.s)) {
        return 0, io.EOF
    }
    b := r.s[r.i]
    r.i++
    return b, nil
}

和ReadByte一起实现io.ByteScanner接口

func (r *Reader) UnreadByte() error {
    if r.i <= 0 {
        return errors.New("bytes.Reader.UnreadByte: at beginning of slice")
    }
    
    r.prevRune = -1
    r.i--
    return nil
}

实现 io.Seeker 接口

func (r *Reader) Seek(offset int64, whence int) (int64, error) {
    r.prevRune = -1
    var abs int64

    switch whence {
    case io.SeekStart:
        abs = offset
    case io.SeekCurrent:
        abs = r.i + offset
    case io.SeekEnd:
        abs = int64(len(r.s)) + offset
    default:
        return 0, errors.New("bytes.Reader.Seek: invalid whence")
    }
    
    if abs < 0 {
        return 0, errors.New("bytes.Reader.Seek: negative position")
    }
    
    r.i = abs
    return abs, nil
}

实现 io.WriterTo 接口

func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
    r.prevRune = -1
    if r.i >= int64(len(r.s)) {
        return 0, nil
    }
    b := r.s[r.i:]
    m, err := w.Write(b)
    if m > len(b) {
        panic("bytes.Reader.WriteTo: invalid Write count")
    }
    
    r.i += int64(m)
    n = int64(m)
    if m != len(b) && err == nil {
        err = io.ErrShortWrite
    }
    return
}

strings.Reader 实现原理差不多。