Go编程技巧--io.Reader/Writer

最新推荐文章于 2024-09-11 08:39:26 发布
最新推荐文章于 2024-09-11 08:39:26 发布
阅读量849 收藏 2
点赞数
分类专栏： Go语言 文章标签： golang

Go原生的pkg中有一些核心的interface，其中io.Reader/Writer是比较常用的接口。很多原生的结构都围绕这个系列的接口展开，在实际的开发过程中，你会发现通过这个接口可以在多种不同的io类型之间进行过渡和转化。本文结合实际场景来总结一番。

总览

在这里插入图片描述
围绕io.Reader/Writer，有几个常用的实现：

  • net.Conn, os.Stdin, os.File: 网络、标准输入输出、文件的流读取
  • strings.Reader: 把字符串抽象成Reader
  • bytes.Reader: 把[]byte抽象成Reader
  • bytes.Buffer: 把[]byte抽象成Reader和Writer
  • bufio.Reader/Writer: 抽象成带缓冲的流读取（比如按行读写）

这些实现对于初学者来说其实比较难去记忆，在遇到实际问题的时候更是一脸蒙圈，不知如何是好。下面用实际的场景来举例

什么是 io.Reader

type Reader interface {
  Read(p []byte) (n int, err error)
}
  • Reader 接口仅有一个 Read 方法，所以只要实现了Read(p []byte) (n int, err
    error)方法的类型，我们就认为其类型就是 Reader。
  • Read 方法会把读取的数据复制到 p 中 ，一次只能读取最高不超过 len(p) 的数据，并不保证一定会读满整个 p，读取的数据量返回到
    n，并在读完的时候返回 io.EOF 到 err。
  • Read 方法可以从不同来源读取数据，这个来源可能是文件、网络传输的数据或者普通的字符串，io.Reader
    接口不关心数据从哪里来，只要实现了 Read 方法，就能从来源处读数据。

标准库中的 io.Reader

在 go 标准库中，是有一些实现 io.Reader 接口的类型，这些也是 io.Reader 读数据的不同来源，下面列举下：

读文件时，通过 os.Open 打开一个文件，os.Open 会返回一个 Reader

var r io.Reader
var err error
r, err = os.Open("file.txt")

一个普通的字符串可通过 strings.NewReader 初始化一个 Reader

var r io.Reader
r = strings.NewReader("Read will return these bytes")

在网络传输中，http.Request 的 body 类型也是一个 Reader

var r io.Reader
req := http.Request{}
r = req.Body

bytes.Buffer 也是一个 Reader

var r io.Reader
var buf bytes.Buffer
r = &buf

如何使用 io.Reader

通过编写如下程序，使用 File.Read 的方法进行读取。

package main

import (
	"io"
	"log"
	"os"
)

func main() {
	file, err := os.Open("./book.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()
	bytesRead := make([]byte, 4)
	for {
		n, err := file.Read(bytesRead)
		// 读到文件的结尾，err 是 io.EOF
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatalf("error reading from book.txt: %v", err)
			break
		}
		if n > 0 {
			log.Printf("We read \"%s\" into bytesRead (%d bytes)",
				string(bytesRead[:n]), n)
		}
	}
}

结果

2022/07/10 12:04:22 We read "this" into bytesRead (4 bytes)
2022/07/10 12:04:22 We read " is " into bytesRead (4 bytes)
2022/07/10 12:04:22 We read "a bo" into bytesRead (4 bytes)
2022/07/10 12:04:22 We read "ok.
" into bytesRead (4 bytes)

上面已说过 io.reader 接口的本质是从不同的源读取数据，而这里的来源是文件，程序中的 file 变量是实现了 Read 方法的 Reader 类型，所以可以调用 Read 方法从文件中读数据，然后 copy 到 bytesRead 中。
可能不少小伙伴对最后 string(bytesRead[:n]) 的 re-slice 有些疑惑，这里如果不 re-slice下，打印的结果是不对的；因为 bytesRead 会保存上一次调用的读取的结果，感兴趣的小伙伴可以实践下～

版本一在日常的开发中我们基本不用，因为太繁琐，我们可以使用的 io.ReadAll 方法简化代码，感兴趣的小伙伴可以看下 io.ReadAll 源码，本质是把版本一的for循环封装了下。

package main

import (
   "io"
   "log"
   "os"
)

func main() {
   file, err := os.Open("./book.txt")
   if err != nil {
      panic(err)
   }
   defer file.Close()
   bytesRead, err := io.ReadAll(file)
   if err != nil {
      log.Fatalf("error reading from book.txt: %v", err)
   }
   log.Printf("We read "%s" into bytesRead (%d bytes)",
      string(bytesRead), len(bytesRead))
}

结果

2022/07/10 12:42:41 We read "this is a book.
" into bytesRead (16 bytes)

使用 os.ReadFile 在上一次基础上再次封装下，把 os.Open 也封装在内，这个方法是最常用的，因为足够简单。

package main

import (
   "log"
   "os"
)

func main() {
   bytesRead, err := os.ReadFile("./book.txt")
   if err != nil {
      return
   }
   log.Printf("We read "%s" into bytesRead (%d bytes)",
      string(bytesRead), len(bytesRead))
}

从字符串中初始化 io.Reader

从字符串(源)中读数据，然后 copy 到 buf 中。

package main

import (
    "io"
    "log"
    "strings"
)

func main() {
    s := strings.NewReader("this is a book.")
    buf := make([]byte, 5)
    for {
        n, err := s.Read(buf)
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("error reading from book.txt: %v", err)
            break
        }

        if n > 0 {
            log.Printf("We read \"%s\" into bytesRead (%d bytes)",
                string(buf[:n]), len(buf))
        }
    }
}

结果

2022/07/10 13:03:32 We read "this " into bytesRead (5 bytes)
2022/07/10 13:03:32 We read "is a " into bytesRead (5 bytes)
2022/07/10 13:03:32 We read "book." into bytesRead (5 bytes)

其实本质和读文件类似，也可以使用 os.ReadAll(s) 简化下程序，这里不再赘述。

另一个使用比较广泛是反序列化一些json数据，比如我们有个json数据，想反序列化到结构体中，通过如下代码可以操作成功。

package main

import (
   "encoding/json"
   "log"
   "strings"
)

type Student struct {
   Name string `json:"name"`
   Sex  string `json:"sex"`
}

func main() {
   jsonData := `
            {
                "name":"zhangsan",
                "sex":"boy"
            }`

   rdr := strings.NewReader(jsonData)

   var s Student
   if err := json.NewDecoder(rdr).Decode(&s); err != nil {
      log.Fatalf("error deserializing JSON: %v", err)
      return
   }

   log.Printf("Hi! I'm a %s! \n", s.Name)
}

json.NewDecoder 接收 io.reader 类型的数据，rdr 是 io.reader 类型，可以从 rdr 读数据。
读到数据后，通过 json.Decoder.Decode 方法解码 json 数据，也就是反序列化一个结构体

网络传输中获取一个 reader

package main

import (
    "fmt"
    "io"
    "log"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "baidu.com:80")
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

    buf := make([]byte, 200)
    for {
        n, err := conn.Read(buf)
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("error reading from conn: %v", err)
            break
        }
        if n > 0 {
            log.Printf("We read "%s" into bytesRead (%d bytes)",
                string(buf[:n]), n)
        }
    }
}

运行以上程序，输出为:

2022/07/10 13:24:57 We read "HTTP/1.1 200 OK
Date: Sun, 10 Jul 2022 05:24:57 GMT
Server: Apache
Last-Modified: Tue, 12 Jan 2010 13:48:00 GMT
ETag: "51-47cf7e6ee8400"
Accept-Ranges: bytes
Content-Length: 81
Cache-Control: m" into bytesRead (200 bytes)
2022/07/10 13:24:57 We read "ax-age=86400
Expires: Mon, 11 Jul 2022 05:24:57 GMT
Connection: Close
Content-Type: text/html

<html>
<meta http-equiv="refresh" content="0;url=http://www.baidu.com/">
</html>
" into bytesRead (181 bytes)

本质和读文件类似，也可以使用 io.ReadAll(conn) 简化下程序，简化后清爽了许多。

package main

import (
   "fmt"
   "io"
   "log"
   "net"
)

func main() {
   conn, err := net.Dial("tcp", "baidu.com:80")
   if err != nil {
      panic(err)
   }
   defer conn.Close()

   fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")

   data, _ := io.ReadAll(conn)
   log.Printf("Hi! I'm a %s! \n", string(data))
}

如上所见，io.Reader 是一个很方便用的接口，这也是为什么在 go 代码中，随处可见 io.Readers，所以这是一个你真的需要掌握的知识点~

绛洞花主敏明
关注
专栏目录
go语言io reader_简谈GO语言I/O操作
weixin_42504649的博客
01-17 466
1.格式化输出fmt.Printf() 输出到控制台.fmt.PrintLn()输出到控制台并换行。str := fmt.Sprintf("%f", 3.1415926)格式化后返回格式化后的字符串。fmt.FprintLn(os.Stdout, "hello world")格式化输出到输出ioWrite上(控制台、文件、网络请求等)更多操作请见https://studygolang.com/st...
Go学习笔记(1)—io.ReaderWriter
LanceJerry的博客
12-08 972
Go学习笔记(1)—io.Reader/Writer 一、概念 ​ io.Reader/Writer是Go语言中的pkg的一个核心interface。由此展开很多原生接口，可以在开发过程中，通过这个interface来实现不同的io类型之间的转换。 如上图所示，围绕io.Reader/Writer，有几个常用的实现： net.Conn, os.Stdin, os.File: 网络、标准输入输出、文件的流读取 strings.Reader: 把字符串抽象成Reader bytes.Reader: 把[]b
Go语言中io.Reader和io.Writer的详解与实现
09-21
在Go语言的实际编程中，几乎所有的数据结构都围绕接口展开，接口是Go语言中所有数据结构的核心。在使用Go语言的过程中，无论你是实现web应用程序，还是控制台输入输出，又或者是网络操作，不可避免的会遇到IO操作，使用到io.Reader和io.Writer接口。下面来详细看看。
go语言中io操作中的 io.Reader 和 io.Writer的获取方法 总结
05-12 816
我们在对文件进行io操作的时候，经常看到需要我们传递一个 io.Reader 或者 io.Writer 对象作为读写的入参， 那么我们该如何或者这些个RW对象呢？ 其实很简单，你只需要查找一下哪些对象实现了 Read或者 Writer方法，那么你只需要创建一个实现了这2个方法之一的对象 ， 那他就可以是一个 io.Reader 或者 io.Writer 。当然最常见的应该就是我们的 os.File对象了， 另外还有 bufio.Reader， bytes.Buffer 等对象都可以作为io的RW入参。
Golang数据流处理：掌握Reader和Writer接口的技巧
最新发布
walkskyer的博客
09-11 1239
Reader接口位于Golang的io参数说明p []byte: 这是一个字节切片，用于存储读取到的数据。返回值说明n int: 表示成功读取的字节数。err error: 如果读取过程中发生错误，将返回一个非nil的错误值；如果读取到文件末尾，通常会返回io.EOF。通过实现这个接口，您可以定义自己的数据源，并使用标准库中的工具对其进行操作。同样地，Writer接口也位于io参数说明p []byte: 包含要写入的数据的字节切片。返回值说明n int: 表示成功写入的字节数。err error。
Go_io.Reader
非晓为骁的博客
12-17 8988
整理了一些实现io.Reader接口的类
Go 学习之 io.Reader 从源码了解如何编写
叮当猫的喵i
09-04 445
Go 入门很简单：Writer和Reader接口Go语言实战笔记（十九）| Go Writer 和 ReaderGo学习笔记(1)—io.ReaderWritergolang io.Reader和io.Writer 作用 常用的几个实现 围绕，有几个常用的实现：
go依赖包golang.org/x下的所有源码
05-04
10. **io/**：输入输出接口包，定义了读写数据的一般接口，如`io.Reader`和`io.Writer`，这些接口在许多其他包中被广泛使用。 11. **context/**：上下文包，`context.Context`用于在请求处理过程中传递取消信号、...
counting:包计数提供包装器以将计数添加到 io.Reader 和 io.Writer
05-31
在 Go 语言中，`counting` 包是一个非常实用的工具，它为 `io.Reader` 和 `io.Writer` 接口提供了计数功能。这个包使得开发者能够追踪读取或写入的数据量，这对于调试、性能分析或者实现特定的逻辑（比如限制数据...
Go-WriterSeeker是标准库中缺少的内存中的io.WriteSeeker实现
08-14
在Go语言中，`io`包提供了一系列接口和基本的I/O操作，如`Reader`、`Writer`和`Seeker`。这些接口是构建高效、灵活的输入输出系统的基础。然而，在标准库中，有时我们可能会发现缺少一个直接满足特定需求的实现，...
golang之bufio包的使用
diaoliu7156的博客
09-16 389
原文地址:http://www.niu12.com/article/38 github地址:https://github.com/ZQCard/go_api_practice // 参考：https://www.cnblogs.com/golove/p/3282667.html// bufio 包实现了带缓存的 I/O 操作// 它封装一个 io.Reader 或 io.Writer...
io.Writer
10-07 199
var w io.Writer // 设置为你的 io.Writer var b bytes.Buffer fmt.Fprint(&b, "Hello World") w = &b fmt.Println("===== ", w) orm.DebugLog = orm.NewLog(w) 转载于:https://www.cnblogs.com/thankyouGo...
golang中的io.Reader/Writer
热门推荐
Mr.Phoebe的专栏
04-09 2万+
本文整理自Go编程技巧–io.Reader/Writer Go原生的包中有一些核心的interface，其中io.Reader/Writer是比较常用的接口。很多原生的结构都围绕这个系列的接口展开，在实际的开发过程中，你会发现通过这个接口可以在多种不同的io类型之间进行过渡和转化。本文结合实际场景来总结一番。 关系图表 type Reader interface { Read(p []b...
Go语言中的io.Reader和io.Writer以及它们的实现
笔记
11-05 2912
在使用Go语言的过程中，无论你是实现web应用程序，还是控制台输入输出，又或者是网络操作，不可避免的会遇到IO操作，使用到io.Reader和io.Writer接口。也也许对这两个接口和相关的一些接口很熟悉了，但是你脑海里确很难形成一个对io接口的继承关系整天的概貌，原因在于godoc缺省并没有像javadoc一样显示官方库继承关系，这导致了我们对io接口的继承关系记忆不深，在使用的时候还经常需要翻文档加深记忆。本文试图梳理清楚Go io接口的继承关系，提供一个io接口的全貌。 io接口回顾 首先我们回
io流的Writer(写)和Reader(读)
ypf3442354429的博客
05-12 1613
Writer与Reader类不能直接调用,需要使用多带的方法调用它们的子类,在他们的前边加上一个File即可如(FileWriter或FileReader)的多态方法进行其调用,并且他们也是抽象类调用需要连接接口Exception,它们的优点在于可以直接写入或读出内容,不需要使用byte转八进制。 接口连接: public static void main(String[] args) throws Exception io流的所有方法都需要链接他们的接口父类,Exception。 一:Wri
go里面的io-Writerr操作
小师life的博客
04-24 3441
将string转换成 io.Writer，可以进行类似于write的操作，类似于写文件一样。 s := "Hello" buf := bytes.NewBufferString(s) fmt.Fprint(buf, ", World!") fmt.Println(buf.String()) 同样的，打开的文件也可以被转换成 io.Writer，继而直接向其写入数据。 f, err := os....
go语言io reader_go语言学习笔记---读取文件io/ioutil 包
weixin_39687192的博客
01-17 880
名称作用备注ReadAll读取数据，返回读到的字节 sliceReadDir读取一个目录，返回目录入口数组[]os.FileInfo,ReadFile读一个文件，返回文件内容(字节slice)WriteFile根据文件路径，写入字节sliceTempDir在一个目录中创建指定前缀名的临时目录，返回新临时目录的路径TempFile在一个目录中创建指定前缀名的临时文件，返回 os.File示例Rea...
go IO操作-文件读
go|Python的个人博客
07-22 854
文件读取是所有编程语言中最常见的操作之一。我们会学习如何使用Go读取文件。使用File自带的Read方法，使用os.Open()或打开文件（Open本质还是调用了OpenFile）使用bufio库的Read方法，使用r(文件对象),也需要先打开文件使用io/ioutil库的ReadAll(),使用(文件路径)，本质还是调用了bufio>>File自带Read模式含义只写创建文件只读os.O_RDWR读写os.O_TRUNC清空追加。...
Go语言IO详解：Reader与Writer接口
"这篇文档详细介绍了Go语言中的IO操作，主要关注了`io`包、`io/ioutil`、`fmt`、`bufio`这四个与IO相关的包，并且重点讲解了`io`包中的`Reader`和`Writer`接口。" 在Go语言中，IO操作是程序与外部世界交互的关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值