go把io.ReadCloser类型转化为[]byte

2019独角兽企业重金招聘Python工程师标准>>>

//比如要解析resp.Body(io.ReadCloser)，我们可以这样处理
body, err := ioutil.ReadAll(resp.Body)

接着，我们继续分析分析函数

func ReadAll(r io.Reader) ([]byte, error) {
	return readAll(r, bytes.MinRead) //const MinRead = 512
}
//
func readAll(r io.Reader, capacity int64) (b []byte, err error) {
	buf := bytes.NewBuffer(make([]byte, 0, capacity))
//func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} } 一个新的buffer实例

	defer func() {
		e := recover()
		if e == nil {
			return
		}
		//buf太大会返回相应错误
		if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
			err = panicErr
		} else {
			panic(e)
		}
	}()
	_, err = buf.ReadFrom(r) //关键就是这个家伙
	return buf.Bytes(), err
}

来继续看看 buf.ReadFrom的实现吧：

//先看一下Buffer的定义，有帮助下面理解
type Buffer struct {
	buf       []byte            // 最新数据存放在 buf[off : len(buf)]
	off       int               // 从&buf[off]开始读, 从&buf[len(buf)]开始写
	runeBytes [utf8.UTFMax]byte // avoid allocation of slice on each WriteByte or Rune
	bootstrap [64]byte          
	// memory to hold first slice; helps small buffers (Printf) avoid allocation.
	lastRead  readOp            // last read operation, so that Unread* can work correctly.
}


func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
	b.lastRead = opInvalid // 0
	if b.off >= len(b.buf) { 
		b.Truncate(0) //还没有写就想读，清空buf
	}
	for {
		if free := cap(b.buf) - len(b.buf); free < MinRead {
			// free的大小是总容量 - 现在占有长度
			newBuf := b.buf
			if b.off+free < MinRead {
                                //分配更大空间，分配失败会报错
				newBuf = makeSlice(2*cap(b.buf) + MinRead)
			}
			//把读的内容b.buf[b.off:]拷贝到newbuf前面去
			copy(newBuf, b.buf[b.off:])
			//读写之间的差距就是应该读的buf
			b.buf = newBuf[:len(b.buf)-b.off]
			b.off = 0
		}
		//把io.Reader内容写到buf的free中去
		m, e := r.Read(b.buf[len(b.buf):cap(b.buf)])
		//重新调整buf的大小
		b.buf = b.buf[0 : len(b.buf)+m]
		n += int64(m)
		//读到尾部就返回
		if e == io.EOF {
			break
		}
		if e != nil {
			return n, e
		}
	}
	return n, nil // err is EOF, so return nil explicitly
}

接下来再来看看是怎么Read进buf里面去的吧：

func (b *Buffer) Read(p []byte) (n int, err error) {
	b.lastRead = opInvalid
	if b.off >= len(b.buf) {
		// Buffer is empty, reset to recover space.
		b.Truncate(0)
		if len(p) == 0 {
			return
		}
		return 0, io.EOF
	}
	//就是这里咯，把b.buf[b.off:]的值写到p中去，记住copy(s1,s2)是s2写到s1中去，不要弄反咯
	//而且此Buffer其实是io.ReadCloser接口转化的类型
	n = copy(p, b.buf[b.off:])
	b.off += n
	if n > 0 {
		b.lastRead = opRead
	}
	return
}

总之，这里分析比较少脑筋的代码就是那个ReadFrom里面修改buf大小那里的逻辑，确实有点绕。。。。。。

转载于:https://my.oschina.net/yang1992/blog/502564