共计 3409 个字符，预计需要花费 9 分钟才能阅读完成。
原文链接： [如何在 Go 中将 []byte 转换为 io.Reader？](https://mp.weixin.qq.com/s/nF…)
在 stackoverflow 上看到一个问题，题主进行了一个网络申请，接口返回的是 []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 等，这里就不一一介绍了。这部分代码并不简单，读起来很轻松，而且还能加深对接口的了解，举荐大家看看。
好了，本文就到这里吧。关注我，带你通过问题读 Go 源码。
举荐浏览：
- 开始读 Go 源码了
激情举荐：
- 计算机经典书籍（含下载方式）
- 技术博客： 硬核后端技术干货，内容包含 Python、Django、Docker、Go、Redis、ElasticSearch、Kafka、Linux 等。
- Go 程序员： Go 学习路线图，包含根底专栏，进阶专栏，源码浏览，实战开发，面试刷题，必读书单等一系列资源。
- 面试题汇总： 包含 Python、Go、Redis、MySQL、Kafka、数据结构、算法、编程、网络等各种常考题。
参考文章：
- https://books.studygolang.com…
- https://www.cnblogs.com/jiuju…
- https://segmentfault.com/a/11…
