如何在Go中将[]byte转换为io.Reader

在 * 上看到一个问题，题主进行了一个网络请求，接口返回的是 []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 语言中，也提供了一系列标准库来应对这些操作，主要封装在以下几个包中：

1. io：基本的 io 操作接口。
2. io/ioutil：封装了一些实用的 io 函数。
3. fmt：实现了 io 格式化操作。
4. bufio：实现了带缓冲的 io。
5. net.conn：网络读写。
6. os.stdin，os.stdout：系统标准输入输出。
7. os.file:系统文件操作。
8. bytes：字节相关 io 操作。

除了 io.reader 和 io.writer 之外，io 包还封装了很多其他基本接口，比如 readerat，writerat，readerfrom 和 writerto 等，这里就不一一介绍了。这部分代码并不复杂，读起来很轻松，而且还能加深对接口的理解，推荐大家看看。

到此这篇关于如何在go中将[]byte转换为io.reader的文章就介绍到这了,更多相关go []byte转换为io.reader内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！