社区微信群开通啦，扫一扫抢先加入社区官方微信群
社区微信群
社区微信群开通啦，扫一扫抢先加入社区官方微信群
社区微信群
第1章：输入和输出
第2章：文本
第3章：数据结构与算法
第4章：日期与时间
第5章：数学函数
第6章：文件系统
第7章：数据持久存储与交换
第8章：数据压缩与归档
第9章：测试
第10章：进程、线程和 goroutine
第13章：应用构建 与 debug
第15章：
第16章：
一般的，计算机程序是：输入 (Input) 经过算法处理产生输出 (Output)。各种语言一般都会提供IO库供开发者使用。Go语言也不例外。
Go 语言中，为了方便开发者使用，将 IO 操作封装在了如下几个包中：
io 包为 I/O 原语提供了基本的接口。它主要包装了这些原语的已有实现。
由于这些被接口包装的I/O原语是由不同的低级操作实现，因此，在另有声明之前不该假定它们的并发执行是安全的。
在 io 包中最重要的是两个接口：Reader 和 Writer 接口。本章所提到的各种 IO 包，都跟这两个接口有关，也就是说，只要满足这两个接口，它就可以使用 IO 包的功能。
Reader 接口的定义如下：
type Reader interface {
Read(p []byte) (n int, err error)
}
官方文档中关于该接口方法的说明：
Read 将 len§ 个字节读取到 p 中。它返回读取的字节数 n（0 <= n <= len§） 以及任何遇到的错误。即使 Read 返回的 n < len§，它也会在调用过程中占用 len§ 个字节作为暂存空间。若可读取的数据不到 len§ 个字节，Read 会返回可用数据，而不是等待更多数据。
当 Read 在成功读取 n > 0 个字节后遇到一个错误或 EOF (end-of-file)，它会返回读取的字节数。它可能会同时在本次的调用中返回一个non-nil错误,或在下一次的调用中返回这个错误（且 n 为 0）。 一般情况下, Reader会返回一个非0字节数n, 若 n = len§ 个字节从输入源的结尾处由 Read 返回，Read可能返回 err == EOF 或者 err == nil。并且之后的 Read() 都应该返回 (n:0, err:EOF)。
调用者在考虑错误之前应当首先处理返回的数据。这样做可以正确地处理在读取一些字节后产生的 I/O 错误，同时允许EOF的出现。
根据 Go 语言中关于接口和满足了接口的类型的定义（Interface_types），我们知道 Reader 接口的方法集（Method_sets）只包含一个 Read 方法，因此，所有实现了 Read 方法的类型都满足 io.Reader 接口，也就是说，在所有需要 io.Reader 的地方，可以传递实现了 Read() 方法的类型的实例。
下面，我们通过具体例子来谈谈该接口的用法。
func ReadFrom(reader io.Reader, num int) ([]byte, error) {
p := make([]byte, num)
n, err := reader.Read(p)
if n > 0 {
return p[:n], nil
}
return p, err
}
ReadFrom 函数将 io.Reader 作为参数，也就是说，ReadFrom 可以从任意的地方读取数据，只要来源实现了 io.Reader 接口。比如，我们可以从标准输入、文件、字符串等读取数据，示例代码如下：
// 从标准输入读取
data, err = ReadFrom(os.Stdin, 11)
// 从普通文件读取，其中 file 是 os.File 的实例
data, err = ReadFrom(file, 9)
// 从字符串读取
data, err = ReadFrom(strings.NewReader("from string"), 12)
完整的演示例子源码见 code/src/chapter01/io/reader.go
小贴士
io.EOF 变量的定义：var EOF = errors.New("EOF")，是 error 类型。根据 reader 接口的说明，在 n > 0 且数据被读完了的情况下，返回的 error 有可能是 EOF 也有可能是 nil。
Writer 接口的定义如下：
type Writer interface {
Write(p []byte) (n int, err error)
}
官方文档中关于该接口方法的说明：
Write 将 len§ 个字节从 p 中写入到基本数据流中。它返回从 p 中被写入的字节数 n（0 <= n <= len§）以及任何遇到的引起写入提前停止的错误。若 Write 返回的 n < len§，它就必须返回一个 非nil 的错误。
同样的，所有实现了Write方法的类型都实现了 io.Writer 接口。
在上个例子中，我们是自己实现一个函数接收一个 io.Reader 类型的参数。这里，我们通过标准库的例子来学习。
在fmt标准库中，有一组函数：Fprint/Fprintf/Fprintln，它们接收一个 io.Wrtier 类型参数（第一个参数），也就是说它们将数据格式化输出到 io.Writer 中。那么，调用这组函数时，该如何传递这个参数呢？
我们以 fmt.Fprintln 为例，同时看一下 fmt.Println 函数的源码。
func Println(a ...interface{}) (n int, err error) {
return Fprintln(os.Stdout, a...)
}
很显然，fmt.Println会将内容输出到标准输出中。下一节我们将详细介绍fmt包。
关于 io.Writer 的更多说明，可以查看笔者之前写的博文《以io.Writer为例看go中的interface{}》。
初学者看到函数参数是一个接口类型，很多时候有些束手无策，不知道该怎么传递参数。还有人问：标准库中有哪些类型实现了 io.Reader 或 io.Writer 接口？
通过本节上面的例子，我们可以知道，os.File 同时实现了这两个接口。我们还看到 os.Stdin/Stdout 这样的代码，它们似乎分别实现了 io.Reader/io.Writer 接口。没错，实际上在 os 包中有这样的代码：
var (
Stdin = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
)
也就是说，Stdin/Stdout/Stderr 只是三个特殊的文件类型的标识（即都是 os.File 的实例），自然也实现了 io.Reader 和 io.Writer。
目前，Go 文档中还没有直接列出实现了某个接口的所有类型。不过，我们可以通过查看标准库文档，列出实现了 io.Reader 或 io.Writer 接口的类型（导出的类型）：（注：godoc 命令支持额外参数 -analysis ，能列出都有哪些类型实现了某个接口，相关参考 godoc -h 或 Static analysis features of godoc。另外，我做了一个官网镜像，能查看接口所有的实现类型，地址：http://docs.studygolang.com。
除此之外，io 包本身也有这两个接口的实现类型。如：
实现了 Reader 的类型：LimitedReader、PipeReader、SectionReader
实现了 Writer 的类型：PipeWriter
以上类型中，常用的类型有：os.File、strings.Reader、bufio.Reader/Writer、bytes.Buffer、bytes.Reader
小贴士
从接口名称很容易猜到，一般地， Go 中接口的命名约定：接口名以 er 结尾。注意，这里并非强行要求，你完全可以不以 er 结尾。标准库中有些接口也不是以 er 结尾的。
ReaderAt 接口的定义如下：
type ReaderAt interface {
ReadAt(p []byte, off int64) (n int, err error)
}
官方文档中关于该接口方法的说明：
ReadAt 从基本输入源的偏移量 off 处开始，将 len§ 个字节读取到 p 中。它返回读取的字节数 n（0 <= n <= len§）以及任何遇到的错误。
当 ReadAt 返回的 n < len§ 时，它就会返回一个 非nil 的错误来解释 为什么没有返回更多的字节。在这一点上，ReadAt 比 Read 更严格。
即使 ReadAt 返回的 n < len§，它也会在调用过程中使用 p 的全部作为暂存空间。若可读取的数据不到 len§ 字节，ReadAt 就会阻塞,直到所有数据都可用或一个错误发生。 在这一点上 ReadAt 不同于 Read。
若 n = len§ 个字节从输入源的结尾处由 ReadAt 返回，Read可能返回 err == EOF 或者 err == nil
若 ReadAt 携带一个偏移量从输入源读取，ReadAt 应当既不影响偏移量也不被它所影响。
可对相同的输入源并行执行 ReadAt 调用。
可见，ReaderAt 接口使得可以从指定偏移量处开始读取数据。
简单示例代码如下：
reader := strings.NewReader("Go语言中文网")
p := make([]byte, 6)
n, err := reader.ReadAt(p, 2)
if err != nil {
panic(err)
}
fmt.Printf("%s, %d\n", p, n)
输出：
语言, 6
WriterAt 接口的定义如下：
type WriterAt interface {
WriteAt(p []byte, off int64) (n int, err error)
}
官方文档中关于该接口方法的说明：
WriteAt 从 p 中将 len§ 个字节写入到偏移量 off 处的基本数据流中。它返回从 p 中被写入的字节数 n（0 <= n <= len§）以及任何遇到的引起写入提前停止的错误。若 WriteAt 返回的 n < len§，它就必须返回一个 非nil 的错误。
若 WriteAt 携带一个偏移量写入到目标中，WriteAt 应当既不影响偏移量也不被它所影响。
若被写区域没有重叠，可对相同的目标并行执行 WriteAt 调用。
我们可以通过该接口将数据写入到数据流的特定偏移量之后。
通过简单示例来演示 WriteAt 方法的使用（os.File 实现了 WriterAt 接口）：
file, err := os.Create("writeAt.txt")
if err != nil {
panic(err)
}
defer file.Close()
file.WriteString("Golang中文社区——这里是多余")
n, err := file.WriteAt([]byte("Go语言中文网"), 24)
if err != nil {
panic(err)
}
fmt.Println(n)
打开文件 WriteAt.txt，内容是：Golang中文社区——Go语言中文网。
分析：
file.WriteString("Golang中文社区——这里是多余") 往文件中写入 Golang中文社区——这里是多余，之后 file.WriteAt([]byte("Go语言中文网"), 24) 在文件流的 offset=24 处写入 Go语言中文网（会覆盖该位置的内容）。
ReaderFrom 的定义如下：
type ReaderFrom interface {
ReadFrom(r Reader) (n int64, err error)
}
官方文档中关于该接口方法的说明：
ReadFrom 从 r 中读取数据，直到 EOF 或发生错误。其返回值 n 为读取的字节数。除 io.EOF 之外，在读取过程中遇到的任何错误也将被返回。
如果 ReaderFrom 可用，Copy 函数就会使用它。
注意：ReadFrom 方法不会返回 err == EOF。
下面的例子简单的实现将文件中的数据全部读取（显示在标准输出）：
file, err := os.Open("writeAt.txt")
if err != nil {
panic(err)
}
defer file.Close()
writer := bufio.NewWriter(os.Stdout)
writer.ReadFrom(file)
writer.Flush()
当然，我们可以通过 ioutil 包的 ReadFile 函数获取文件全部内容。其实，跟踪一下 ioutil.ReadFile 的源码，会发现其实也是通过 ReadFrom 方法实现（用的是 bytes.Buffer，它实现了 ReaderFrom 接口）。
如果不通过 ReadFrom 接口来做这件事，而是使用 io.Reader 接口，我们有两种思路：
这里不给出实现代码了，有兴趣的可以实现一下。
提示
通过查看 bufio.Writer 或 strings.Buffer 类型的 ReadFrom 方法实现，会发现，其实它们的实现和上面说的第 2 种思路类似。
WriterTo的定义如下：
type WriterTo interface {
WriteTo(w Writer) (n int64, err error)
}
官方文档中关于该接口方法的说明：
WriteTo 将数据写入 w 中，直到没有数据可写或发生错误。其返回值 n 为写入的字节数。 在写入过程中遇到的任何错误也将被返回。
如果 WriterTo 可用，Copy 函数就会使用它。
读者是否发现，其实 ReaderFrom 和 WriterTo 接口的方法接收的参数是 io.Reader 和 io.Writer 类型。根据 io.Reader 和 io.Writer 接口的讲解，对该接口的使用应该可以很好的掌握。
这里只提供简单的一个示例代码：将一段文本输出到标准输出
reader := bytes.NewReader([]byte("Go语言中文网"))
reader.WriteTo(os.Stdout)
通过 io.ReaderFrom 和 io.WriterTo 的学习，我们知道，如果这样的需求，可以考虑使用这两个接口：“一次性从某个地方读或写到某个地方去。”
接口定义如下：
type Seeker interface {
Seek(offset int64, whence int) (ret int64, err error)
}
官方文档中关于该接口方法的说明：
Seek 设置下一次 Read 或 Write 的偏移量为 offset，它的解释取决于 whence： 0 表示相对于文件的起始处，1 表示相对于当前的偏移，而 2 表示相对于其结尾处。 Seek 返回新的偏移量和一个错误，如果有的话。
也就是说，Seek 方法是用于设置偏移量的，这样可以从某个特定位置开始操作数据流。听起来和 ReaderAt/WriteAt 接口有些类似，不过 Seeker 接口更灵活，可以更好的控制读写数据流的位置。
简单的示例代码：获取倒数第二个字符（需要考虑 UTF-8 编码，这里的代码只是一个示例）
reader := strings.NewReader("Go语言中文网")
reader.Seek(-6, io.SeekEnd)
r, _, _ := reader.ReadRune()
fmt.Printf("%c\n", r)
小贴士
whence 的值，在 io 包中定义了相应的常量，应该使用这些常量
const (
SeekStart = 0 // seek relative to the origin of the file
SeekCurrent = 1 // seek relative to the current offset
SeekEnd = 2 // seek relative to the end
)
而原先 os 包中的常量已经被标注为Deprecated
// Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd.
const (
SEEK_SET int = 0 // seek relative to the origin of the file
SEEK_CUR int = 1 // seek relative to the current offset
SEEK_END int = 2 // seek relative to the end
)
接口定义如下：
type Closer interface {
Close() error
}
该接口比较简单，只有一个 Close() 方法，用于关闭数据流。
文件 (os.File)、归档（压缩包）、数据库连接、Socket 等需要手动关闭的资源都实现了 Closer 接口。
实际编程中，经常将 Close 方法的调用放在 defer 语句中。
小提示
初学者容易写出这样的代码：
file, err := os.Open("studygolang.txt")
defer file.Close()
if err != nil {
...
}
当文件 studygolang.txt 不存在或找不到时，file.Close() 会 panic，因为 file 是 nil。因此，应该将 defer file.Close() 放在错误检查之后。
经过 issue40 提醒，查看源码：
func (f *File) Close() error {
if f == nil {
return ErrInvalid
}
return f.file.close()
}
可见并不会 panic，但在 Close 之前校验错误是个好习惯！
通过名称大概也能猜出这组接口的用途：读或写一个字节。接口定义如下：
type ByteReader interface {
ReadByte() (c byte, err error)
}
type ByteWriter interface {
WriteByte(c byte) error
}
在标准库中，有如下类型实现了 io.ByteReader 或 io.ByteWriter:
接下来的示例中，我们通过 bytes.Buffer 来一次读取或写入一个字节（主要代码）：
var ch byte
fmt.Scanf("%c\n", &ch)
buffer := new(bytes.Buffer)
err := buffer.WriteByte(ch)
if err == nil {
fmt.Println("写入一个字节成功！准备读取该字节……")
newCh, _ := buffer.ReadByte()
fmt.Printf("读取的字节：%c\n", newCh)
} else {
fmt.Println("写入错误")
}
程序从标准输入接收一个字节（ASCII 字符），调用 buffer 的 WriteByte 将该字节写入 buffer 中，之后通过 ReadByte 读取该字节。完整的代码见：code/src/chapter01/io/byterwer.go
一般地，我们不会使用 bytes.Buffer 来一次读取或写入一个字节。那么，这两个接口有哪些用处呢？
在标准库 encoding/binary 中，实现Google-ProtoBuf中的 Varints 读取，ReadVarint 就需要一个 io.ByteReader 类型的参数，也就是说，它需要一个字节一个字节的读取。关于 encoding/binary 包在后面会详细介绍。
在标准库 image/jpeg 中，Encode函数的内部实现使用了 ByteWriter 写入一个字节。
小贴士
可以通过在 Go 语言源码 src/pkg 中搜索 “io.ByteReader” 或 “io.ByteWiter”，获得哪些地方用到了这两个接口。你会发现，这两个接口在二进制数据或归档压缩时用的比较多。
将这三个接口放在一起，是考虑到与 ByteReader 相关或相应。
ByteScanner 接口的定义如下：
type ByteScanner interface {
ByteReader
UnreadByte() error
}
可见，它内嵌了 ByteReader 接口（可以理解为继承了 ByteReader 接口），UnreadByte 方法的意思是：将上一次 ReadByte 的字节还原，使得再次调用 ReadByte 返回的结果和上一次调用相同，也就是说，UnreadByte 是重置上一次的 ReadByte。注意，UnreadByte 调用之前必须调用了 ReadByte，且不能连续调用 UnreadByte。即：
buffer := bytes.NewBuffer([]byte{'a', 'b'})
err := buffer.UnreadByte()
和
buffer := bytes.NewBuffer([]byte{'a', 'b'})
buffer.ReadByte()
err := buffer.UnreadByte()
err = buffer.UnreadByte()
err 都 非nil，错误为：bytes.Buffer: UnreadByte: previous operation was not a read
RuneReader 接口和 ByteReader 类似，只是 ReadRune 方法读取单个 UTF-8 字符，返回其 rune 和该字符占用的字节数。该接口在 regexp 包有用到。
之前有人在QQ群中问道：
strings.Index(“行业交流群”, “交流”) 返回的是单字节字符的位置：6。但是想要的是 unicode 字符的位置：2。
这里借助utf8的RuneCountInString函数,实现代码如下：
// strings.Index 的 UTF-8 版本
// 即 Utf8Index("Go语言中文网", "中文") 返回 4，而不是 strings.Index 的 8
func Utf8Index(str, substr string) int {
index := strings.Index(str, substr)
if index < 0{
return -1
}
return utf8.RuneCountInString(str[:index])
}
RuneScanner 接口和 ByteScanner 类似，就不赘述了。
这些接口是上面介绍的接口的两个或三个组合而成的新接口。例如 ReadWriter 接口：
type ReadWriter interface {
Reader
Writer
}
这是 Reader 接口和 Writer 接口的简单组合（内嵌）。
这些接口的作用是：有些时候同时需要某两个接口的所有功能，即必须同时实现了某两个接口的类型才能够被传入使用。可见，io 包中有大量的“小接口”，这样方便组合为“大接口”。
SectionReader 是一个 struct（没有任何导出的字段），实现了 Read, Seek 和 ReadAt，同时，内嵌了 ReaderAt 接口。结构定义如下：
type SectionReader struct {
r ReaderAt // 该类型最终的 Read/ReadAt 最终都是通过 r 的 ReadAt 实现
base int64 // NewSectionReader 会将 base 设置为 off
off int64 // 从 r 中的 off 偏移处开始读取数据
limit int64 // limit - off = SectionReader 流的长度
}
从名称我们可以猜到，该类型读取数据流中部分数据。看一下
func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader
的文档说明就知道了：
NewSectionReader 返回一个 SectionReader，它从 r 中的偏移量 off 处读取 n 个字节后以 EOF 停止。
也就是说，SectionReader 只是内部（内嵌）ReaderAt 表示的数据流的一部分：从 off 开始后的 n 个字节。
这个类型的作用是：方便重复操作某一段 (section) 数据流；或者同时需要 ReadAt 和 Seek 的功能。
由于该类型所支持的操作，前面都有介绍，因此不提供示例代码了。
关于该类型在标准库中的使用，我们在 8.5 archive/zip — zip归档访问 会讲到。
LimitedReader 结构定义如下：
type LimitedReader struct {
R Reader // underlying reader，最终的读取操作通过 R.Read 完成
N int64 // max bytes remaining
}
文档说明如下：
从 R 读取但将返回的数据量限制为 N 字节。每调用一次 Read 都将更新 N 来反应新的剩余数量。
也就是说，最多只能返回 N 字节数据。
LimitedReader 只实现了 Read 方法（Reader 接口）。
使用示例如下：
content := "This Is LimitReader Example"
reader := strings.NewReader(content)
limitReader := &io.LimitedReader{R: reader, N: 8}
for limitReader.N > 0 {
tmp := make([]byte, 2)
limitReader.Read(tmp)
fmt.Printf("%s", tmp)
}
输出：
This Is
可见，通过该类型可以达到 只允许读取一定长度数据 的目的。
在 io 包中，LimitReader 函数的实现其实就是调用 LimitedReader：
func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
PipeReader（一个没有任何导出字段的 struct）是管道的读取端。它实现了 io.Reader 和 io.Closer 接口。结构定义如下：
type PipeReader struct {
p *pipe
}
关于 PipeReader.Read 方法的说明：从管道中读取数据。该方法会堵塞，直到管道写入端开始写入数据或写入端被关闭。如果写入端关闭时带有 error（即调用 CloseWithError 关闭），该Read返回的 err 就是写入端传递的error；否则 err 为 EOF。
PipeWriter（一个没有任何导出字段的 struct）是管道的写入端。它实现了 io.Writer 和 io.Closer 接口。结构定义如下：
type PipeWriter struct {
p *pipe
}
关于 PipeWriter.Write 方法的说明：写数据到管道中。该方法会堵塞，直到管道读取端读完所有数据或读取端被关闭。如果读取端关闭时带有 error（即调用 CloseWithError 关闭），该Write返回的 err 就是读取端传递的error；否则 err 为 ErrClosedPipe。
使用示例如下：
func main() {
pipeReader, pipeWriter := io.Pipe()
go PipeWrite(pipeWriter)
go PipeRead(pipeReader)
time.Sleep(30 * time.Second)
}
func PipeWrite(writer *io.PipeWriter){
data := []byte("Go语言中文网")
for i := 0; i < 3; i++{
n, err := writer.Write(data)
if err != nil{
fmt.Println(err)
return
}
fmt.Printf("写入字节 %d\n",n)
}
writer.CloseWithError(errors.New("写入段已关闭"))
}
func PipeRead(reader *io.PipeReader){
buf := make([]byte, 128)
for{
fmt.Println("接口端开始阻塞5秒钟...")
time.Sleep(5 * time.Second)
fmt.Println("接收端开始接受")
n, err := reader.Read(buf)
if err != nil{
fmt.Println(err
版权声明：本文来源CSDN，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/weixin_45541665/article/details/126147090
站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。
-
发表于 2023-01-03 20:59:33
- 阅读 ( 362 )
- 分类：Go
如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！
