在 Stack Overflow 上看到一个问题, 题主进行了一个网络请求, 接口返回的是 []byte. 如果想要将其转换成 io.Reader, 需要怎么做呢?
这个问题解决起来并不复杂, 简单几行代码就可以轻松将其转换成功. 不仅如此, 还可以再通过几行代码反向转换回来.
下面听我慢慢给你吹, 首先直接看两段代码.
[]byte 转 io.Reader
- package main
- import (
- "bytes"
- "fmt"
- "log"
- )
- func main() {
- data := []byte("Hello AlwaysBeta")
- // byte slice to bytes.Reader, which implements the io.Reader interface
- reader := bytes.NewReader(data)
- // read the data from reader
- buf := make([]byte, len(data))
- if _, err := reader.Read(buf); err != nil {
- log.Fatal(err)
- }
- fmt.Println(string(buf))
- }
输出:
Hello AlwaysBeta
这段代码先将 []byte 数据转换到 reader 中, 然后再从 reader 中读取数据, 并打印输出.
io.Reader 转 []byte
- package main
- import (
- "bytes"
- "fmt"
- "strings"
- )
- func main() {
- ioReaderData := strings.NewReader("Hello AlwaysBeta")
- // creates a bytes.Buffer and read from io.Reader
- buf := &bytes.Buffer{}
- buf.ReadFrom(ioReaderData)
- // retrieve a byte slice from bytes.Buffer
- data := buf.Bytes()
- // only read the left bytes from 6
- fmt.Println(string(data[6:]))
- }
输出:
AlwaysBeta
这段代码先创建了一个 reader, 然后读取数据到 buf, 最后打印输出.
以上两段代码就是 []byte 和 io.Reader 互相转换的过程. 对比这两段代码不难发现, 都有 NewReader 的身影. 而且在转换过程中, 都起到了关键作用.
那么问题来了, 这个 NewReader 到底是什么呢? 接下来我们通过源码来一探究竟.
源码解析
Go 的 io 包提供了最基本的 IO 接口, 其中 io.Reader 和 io.Writer 两个接口最为关键, 很多原生结构都是围绕这两个接口展开的.
下面就来分别说说这两个接口:
Reader 接口
io.Reader 表示一个读取器, 它将数据从某个资源读取到传输缓冲区. 在缓冲区中, 数据可以被流式传输和使用.
接口定义如下:
- type Reader interface {
- Read(p []byte) (n int, err error)
- }
Read() 方法将 len(p) 个字节读取到 p 中. 它返回读取的字节数 n, 以及发生错误时的错误信息.
举一个例子:
- package main
- import (
- "fmt"
- "io"
- "os"
- "strings"
- )
- func main() {
- reader := strings.NewReader("Clear is better than clever")
- p := make([]byte, 4)
- for {
- n, err := reader.Read(p)
- if err != nil {
- if err == io.EOF {
- fmt.Println("EOF:", n)
- break
- }
- fmt.Println(err)
- os.Exit(1)
- }
- fmt.Println(n, string(p[:n]))
- }
- }
输出:
- 4 Clea
- 4 r is
- 4 bet
- 4 ter
- 4 than
- 4 cle
- 3 ver
- EOF: 0
这段代码从 reader 不断读取数据, 每次读 4 个字节, 然后打印输出, 直到结尾.
最后一次返回的 n 值有可能小于缓冲区大小.
Writer 接口
io.Writer 表示一个编写器, 它从缓冲区读取数据, 并将数据写入目标资源.
- type Writer interface {
- Write(p []byte) (n int, err error)
- }
Write 方法将 len(p) 个字节从 p 中写入到对象数据流中. 它返回从 p 中被写入的字节数 n, 以及发生错误时返回的错误信息.
举一个例子:
- package main
- import (
- "bytes"
- "fmt"
- "os"
- )
- func main() {
- // 创建 Buffer 暂存空间, 并将一个字符串写入 Buffer
- // 使用 io.Writer 的 Write 方法写入
- var buf bytes.Buffer
- buf.Write([]byte("hello world ,"))
- // 用 Fprintf 将一个字符串拼接到 Buffer 里
- fmt.Fprintf(&buf, "welcome to golang !")
- // 将 Buffer 的内容输出到标准输出设备
- buf.WriteTo(os.Stdout)
- }
输出:
hello world , welcome to golang !
bytes.Buffer 是一个结构体类型, 用来暂存写入的数据, 其实现了 io.Writer 接口的 Write 方法.
WriteTo 方法定义:
func (b *Buffer) WriteTo(w io.Writer) (n int64, err error)
WriteTo 方法第一个参数是 io.Writer 接口类型.
转换原理
再说回文章开头的转换问题.
只要某个实例实现了接口 io.Reader 里的方法 Read() , 就满足了接口 io.Reader.
bytes 和 strings 包都实现了 Read() 方法.
- // src/bytes/reader.go
- // NewReader returns a new Reader reading from b.
- func NewReader(b []byte) *Reader {
- return &Reader{
- b, 0, -1
- }
- }
- // src/strings/reader.go
- // NewReader returns a new Reader reading from s.
- // It is similar to bytes.NewBufferString but more efficient and read-only.
- func NewReader(s string) *Reader {
- return &Reader{
- s, 0, -1
- }
- }
在调用 NewReader 的时候, 会返回了对应的 T.Reader 类型, 而它们都是通过 io.Reader 扩展而来的, 所以也就实现了转换.
总结
在开发过程中, 避免不了要进行一些 IO 操作, 包括打印输出, 文件读写, 网络连接等.
在 Go 语言中, 也提供了一系列标准库来应对这些操作, 主要封装在以下几个包中:
io: 基本的 IO 操作接口.
io/ioutil: 封装了一些实用的 IO 函数.
fmt: 实现了 IO 格式化操作.
bufio: 实现了带缓冲的 IO.
net.Conn: 网络读写.
os.Stdin,os.Stdout: 系统标准输入输出.
os.File: 系统文件操作.
bytes: 字节相关 IO 操作.
除了 io.Reader 和 io.Writer 之外, io 包还封装了很多其他基本接口, 比如 ReaderAt,WriterAt,ReaderFrom 和 WriterTo 等, 这里就不一一介绍了. 这部分代码并不复杂, 读起来很轻松, 而且还能加深对接口的理解, 推荐大家看看.
来源: http://developer.51cto.com/art/202112/697093.htm