亲宝软件园·资讯

展开

Go []byte转换为io.Reader

yongxinz 人气:0

在 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 语言中,也提供了一系列标准库来应对这些操作,主要封装在以下几个包中:

  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 等,这里就不一一介绍了。这部分代码并不复杂,读起来很轻松,而且还能加深对接口的理解,推荐大家看看。

加载全部内容

相关教程
猜你喜欢
用户评论