Golang的i/o对象及操作

刺骨的言语ヽ痛彻心扉 2022-10-21 11:49 146阅读 0赞

> 本文部分内容参考：[http://c.biancheng.net/view/5569.html][http_c.biancheng.net_view_5569.html]

### 文章目录 ###

*   *   *   *  字符串转换成 ReadWriter、Reader 或 Writer 对象
         *  一、操作Reader对象
         *   *  1.1、Read()方法
             *  1.2、ReadByte()方法
             *  1.3、ReadBytes()方法
             *  1.4、ReadLine()方法
             *  1.5、ReadRune()方法
             *  1.6、ReadString()方法
             *  1.7、Buffered()方法
             *  1.8、Peek()方法
         *  二、操作Writer对象
         *   *  2.1、Available()方法
             *  2.2、Buffered()方法
             *  2.3、Flush()方法
             *  2.4、WriteRune()方法
             *  2.5、WriteString()方法
         *  三、操作ReadWriter对象

无论是实现 web 应用程序，还是控制台输入输出，又或者是网络操作，都不可避免的会遇到 I/O 操作。  
我们平常在代码中使用的基本类型，如string或者\[\]byte，这些变量的数据都是在用户态下面，如果要写到磁盘，或者写到网卡（网络通信），会触发write系统调用操作，然后系统将用户态下面的数据拷贝到内核态下面的，再由内核态的系统调用写入磁盘，但是从用户态到内核态的转变是要发生系统调用的，而系统调用会影响性能。因此我们希望有一个缓冲空间，每次的write操作都把数据写入到缓冲空间中，等缓冲空间满了，再将缓冲区中的数据拷贝到内核态下，这样就减少了系统调用的次数

> 内核态与用户态、系统调用与库函数、文件IO与标准IO、缓冲区等概念介绍：[https://blog.csdn.net/windeal3203/article/details/79083453][https_blog.csdn.net_windeal3203_article_details_79083453]  
> 一文搞懂用户缓冲区与内核缓冲区[https://blog.csdn.net/Jiangtagong/article/details/108703123][https_blog.csdn.net_Jiangtagong_article_details_108703123]

Go语言标准库的 bufio 包中，实现了对数据 I/O 接口的缓冲功能。这些功能封装于接口 io.ReadWriter、io.Reader 和 io.Writer 中，并对应创建了 ReadWriter、Reader 或 Writer 对象，在提供缓冲的同时实现了一些文本基本 I/O 操作功能。

我们平常使用的字符串或者网络发来的数据并不是 ReadWriter、Reader 或 Writer 对象，而要使用到缓冲区，就要求我们要操作的数据必须得是 ReadWriter、Reader 或 Writer 对象，所以我们要对数据转换成 ReadWriter、Reader 或 Writer 对象。

#### 字符串转换成 ReadWriter、Reader 或 Writer 对象 ####

data := []byte("你吃了吗？我吃了")  // 字符串转为字节切片
    rd := bytes.NewReader(data)  // 字节切片转为Reader对象
    buffRd := bufio.NewReader(rd)  // 将Reader对象放入到缓冲区中

这里只以转换为Reader对象为例，其他的类似，bytes.NewReader方法虽然也能将字节切片转为Reader对象，但是bytes包下面没有提供许多操作文本的API功能，bufio包提供的API更丰富。

### 一、操作Reader对象 ###

#### 1.1、Read()方法 ####

Read() 方法的功能是读取数据，并存放到字节切片 p 中。Read() 执行结束会返回已读取的字节数，因为最多只调用底层的 io.Reader 一次，所以返回的 n 小于或等于 len( p )，当字节流结束时，n 为 0，err 为 io. EOF。

package main
    
    import (
    	"bufio"
    	"bytes"
    	"fmt"
    )
    
    func main() { 
    	data := []byte("你吃了吗？我吃了")
    	rd := bytes.NewReader(data)
    	buffRd := bufio.NewReader(rd)
    	var buf1 [18]byte
    	num1, err := buffRd.Read(buf1[:])       // 注意传递的是切片，而不是数组
    	fmt.Println(string(buf1[:]), num1, err) // 缓冲区较小，最多只能读取缓冲区大的字节
    	var buf2 [28]byte
    	num2, err := buffRd.Read(buf2[:]) // 接着上一次读取的尾部开始
    	fmt.Println(string(buf2[:]), num2, err)
    }
    //你吃了吗？我 18 <nil>
    //吃了

#### 1.2、ReadByte()方法 ####

ReadByte() 方法的功能是读取并返回一个字节，如果没有字节可读，则返回错误信息。

data := []byte("h你吃了吗？我吃了")
    rd := bytes.NewReader(data)
    buffRd := bufio.NewReader(rd)
    c1, err := buffRd.ReadByte()  // 读取英文
    fmt.Println(string(c1), err)  // 输出英文正常
    c2, err := buffRd.ReadByte()  // 读取中文
    fmt.Println(string(c2), err)  // 输出中文正常
    //h <nil>
    //ä <nil>

> 如果文本全部是英文，可以使用该方法，如果是中英混合，可以使用下面的ReadRune()方法

#### 1.3、ReadBytes()方法 ####

ReadBytes() 方法的功能是读取数据直到遇到第一个分隔符，并返回读取的字节序列（包括分隔符）。如果 ReadBytes 在读到第一个分隔符之前出错，它返回已读取的数据和那个错误（通常是 io.EOF）。只有当返回的数据不以分隔符结尾时，返回的 err 才不为空值。

data := []byte("h你吃了吗,我吃了")
    rd := bytes.NewReader(data)
    buffRd := bufio.NewReader(rd)
    var tr byte = ','
    c1, err := buffRd.ReadBytes(tr)
    fmt.Println(string(c1), err)
    c2, err := buffRd.ReadBytes(tr)
    fmt.Println(string(c2), err)

> 分隔符不能为中文，只能是英文。因为分隔符需要是byte类型，也就是一个8位的字节

#### 1.4、ReadLine()方法 ####

ReadLine是一个低级的读行原语。 大多数调用者应该使用ReadBytes(’\\n’)或ReadString(’\\n’)来代替或使用Scanner。

ReadLine尝试返回一行，不包括行结束字节。 如果该行对缓冲区来说太长，则设置isPrefix（英文是是否为前缀的意思）为true并返回该行的开头。 这一行的其余部分将从以后的调用中返回。 返回行的最后一个片段时，isPrefix将为false。 返回的缓冲区只在下一次调用ReadLine之前有效。 ReadLine要么返回一个非nil行，要么返回一个错误，永远不会两者都返回。

ReadLine返回的文本不包括行结束符("\\r\\n"或"\\n")。 如果输入结束时没有最后一行结束，则没有给出任何指示或错误。 在ReadLine之后调用UnreadByte将始终未读取读到的最后一个字节(可能是属于行结束符的字符)，即使该字节不属于ReadLine返回的行。

data := []byte("h你吃了吗？\r\n我吃了\n哈哈")
    rd := bytes.NewReader(data)
    buffRd := bufio.NewReader(rd)
    line, prefix, err := buffRd.ReadLine()
    fmt.Println(string(line), prefix, err)
    
    line2, prefix2, err := buffRd.ReadLine()
    fmt.Println(string(line2), prefix2, err)
    //h你吃了吗？ false <nil>
    //我吃了 false <nil>

> 分隔符可以是/r/n，也可以是/n，或者两者可同时使用

#### 1.5、ReadRune()方法 ####

ReadRune读取一个UTF-8编码的Unicode字符，并返回符文及其字节大小。 如果编码的符文无效，它将只读取一个字节并消耗这一个字节，同时返回unicode.ReplacementChar (U+FFFD)，大小为1。

data := []byte("h你吃了吗？\r\n我吃了\n哈哈")
    rd := bytes.NewReader(data)
    buffRd := bufio.NewReader(rd)
    char, size, err := buffRd.ReadRune()
    fmt.Println(string(char), size, err)
    
    char2, size2, err := buffRd.ReadRune()
    fmt.Println(string(char2), size2, err)
    //h 1 <nil>
    //你 3 <nil>

#### 1.6、ReadString()方法 ####

ReadString读取到输入中分隔符第一次出现为止，返回一个包含分隔符的数据的字符串。 如果ReadString在找到分隔符之前遇到错误，则返回在错误之前读取的数据和错误本身(通常是io.EOF)。 当且仅当返回的数据不以分隔符结尾时，ReadString返回err != nil。

data := []byte("h你吃了吗,我吃了")
    rd := bytes.NewReader(data)
    buffRd := bufio.NewReader(rd)
    var tr byte = ','
    str, err := buffRd.ReadString(tr)
    fmt.Println(string(str), err)
    str2, err := buffRd.ReadString(tr)
    fmt.Println(string(str2), err)
    //h你吃了吗, <nil>
    //我吃了 EOF

#### 1.7、Buffered()方法 ####

Buffered() 方法的功能是返回可从缓冲区读出数据的字节数

data := []byte("h你吃了吗,我吃了")
    rd := bytes.NewReader(data)
    buffRd := bufio.NewReader(rd)
    fmt.Println(buffRd.Buffered())  // 操作前计数
    var buf [12]byte
    n, err := buffRd.Read(buf[:])
    fmt.Println(string(buf[:n]), n, err)
    fmt.Println(buffRd.Buffered())  // 计数时计数
    var buf2 [12]byte
    n2, err := buffRd.Read(buf2[:])
    fmt.Println(string(buf2[:n]), n2, err)
    fmt.Println(buffRd.Buffered())  // 计数后计数
    //0
    //h你吃了� 12 <nil>
    //11
    //�,我吃了

从结果可以看出几个问题：

*  bufio.NewReader(rd)并没有真正的将数据写入到缓冲区，直到使用类似 buffRd.Read()等方法操作时，数据才会写入到该缓冲区对象中
 *  操作的字符是以字节为单位时，中文出现乱码，但是出现问题的就只有这么一个字符，其他字符不受影响

#### 1.8、Peek()方法 ####

Peek返回下一个n个字节，而没有推进读取器，即这些被读取的数据不会从缓冲区中清除。 这些字节在下一个read调用时停止有效。 如果Peek返回的字节小于n，它还会返回一个错误说明原因。 如果n大于缓冲区大小，则错误为ErrBufferFull。

调用Peek会阻止UnreadByte或UnreadRune调用成功，直到下一次读取操作。

data := []byte("h你吃了吗,我吃了")
    rd := bytes.NewReader(data)
    buffRd := bufio.NewReader(rd)
    da, err := buffRd.Peek(4)  // 读取4个字节
    fmt.Println(string(da), err)
    da2, err := buffRd.Peek(10)  // 读取10个字节
    fmt.Println(string(da2), err)
    da3, err := buffRd.Peek(17)  // 读取17个字节
    fmt.Println(string(da3), err)
    //h你 <nil>
    //h你吃了 <nil>
    //h你吃了吗,我 <nil>

### 二、操作Writer对象 ###

操作 Writer 对象的方法共有 7 个，分别是 Available()、Buffered()、Flush()、Write()、WriteByte()、WriteRune() 和 WriteString() 方法

#### 2.1、Available()方法 ####

返回缓冲区中未使用的字节数

package main
    
    import (
    	"bufio"
    	"bytes"
    	"fmt"
    )
    
    func main() { 
    	buf := bytes.NewBuffer(nil) // 创建一个空白的缓冲区
    	wo := bufio.NewWriter(buf)  // 创建Writer对象，该对象使用创建的空白缓冲区作为写入区域
    	fmt.Println("写入前缓冲区未使用的字节数：", wo.Available())
    	var data = []byte("hello")
    	wo.Write(data)
    	fmt.Println("写入后缓冲区未使用的字节数：", wo.Available())
    }
    //写入前缓冲区未使用的字节数： 4096
    //写入后缓冲区未使用的字节数： 4091

#### 2.2、Buffered()方法 ####

返回已写入当前缓冲区中的字节数

package main
    
    import (
    	"bufio"
    	"bytes"
    	"fmt"
    )
    
    func main() { 
    	buf := bytes.NewBuffer(nil) // 创建一个空白的缓冲区
    	wo := bufio.NewWriter(buf)  // 创建Writer对象，该对象使用创建的空白缓冲区作为写入区域
    	fmt.Println("写入前缓冲区使用的字节数：", wo.Buffered())
    	var data = []byte("hello")
    	wo.Write(data)
    	fmt.Println("写入后缓冲区使用的字节数：", wo.Buffered())
    }
    //写入前缓冲区使用的字节数： 0
    //写入后缓冲区使用的字节数： 5

#### 2.3、Flush()方法 ####

把缓冲区中的数据写入底层的 io.Writer，并返回错误信息。如果成功写入，error 返回 nil，否则 error 返回错误原因。

package main
    
    import (
    	"bufio"
    	"bytes"
    	"fmt"
    )
    
    func main() { 
    	buf := bytes.NewBuffer(nil) // 创建一个空白的缓冲区
    	wo := bufio.NewWriter(buf)  // 创建Writer对象，该对象使用创建的空白缓冲区作为写入区域
    	fmt.Println("缓冲区是空白的：", string(buf.Bytes()))
    	var data = []byte("hello")
    	wo.Write(data)
    	fmt.Println("Write操作缓冲区后：", string(buf.Bytes()))
    	wo.Flush()
    	fmt.Println("Write加Flush操作缓冲区后：", string(buf.Bytes()))
    }
    //缓冲区是空白的： 
    //Write操作缓冲区后： 
    //Write加Flush操作缓冲区后： hello

> 结果表明：Write操作并没有将数据写入到缓冲区，而是Write对象指向了数据，等使用Flush操作后才将指向的数据写入缓冲区。但是但数据超过缓冲区的最大值时，就会自动触发Flush操作，并且扩容缓冲区

超过4096个字符后

package main
    
    import (
    	"bufio"
    	"bytes"
    	"fmt"
    )
    
    func main() { 
    	buf := bytes.NewBuffer(nil) // 创建一个空白的缓冲区
    	wo := bufio.NewWriter(buf)  // 创建Writer对象，该对象使用创建的空白缓冲区作为写入区域
    	fmt.Println("缓冲区是空白的：", string(buf.Bytes()))
    	var str string = `giao 此处省略4096个字符 `
    	var data = []byte(str)
    	wo.Write(data)
    	fmt.Println("Write操作缓冲区后：", string(buf.Bytes()))
    	// wo.Flush()
    	// fmt.Println("Write加Flush操作缓冲区后：", string(buf.Bytes()))
    }
    //缓冲区是空白的： 
    //Write操作缓冲区后： giao
    //……

#### 2.4、WriteRune()方法 ####

WriteRune() 方法的功能是以 UTF-8 编码写入一个 Unicode 字符，返回写入的字节数和错误信息。

buf := bytes.NewBuffer(nil) // 创建一个空白的缓冲区
    wo := bufio.NewWriter(buf)  // 创建Writer对象，该对象使用创建的空白缓冲区作为写入区域
    var str rune = '你'
    size, err := wo.WriteRune(str)
    wo.Flush()
    fmt.Println(string(buf.Bytes()), size, err)
    //你 3 <nil>

#### 2.5、WriteString()方法 ####

WriteString() 方法的功能是写入一个字符串，并返回写入的字节数和错误信息。如果返回的字节数小于 len(s)，则同时返回一个错误说明原因。

buf := bytes.NewBuffer(nil) // 创建一个空白的缓冲区
    wo := bufio.NewWriter(buf)  // 创建Writer对象，该对象使用创建的空白缓冲区作为写入区域
    var str = "你好啊~~~"
    size, err := wo.WriteString(str)
    wo.Flush()
    fmt.Println(string(buf.Bytes()), size, err)

### 三、操作ReadWriter对象 ###

ReadWriter对象其实只是整合了Reader对象和Writer对象，使得ReadWriter对象同时具备Reader对象和Writer对象的所有功能

package main
    
    import (
    	"bufio"
    	"bytes"
    	"fmt"
    )
    
    func main() { 
    	readBuf := bytes.NewBuffer(nil)       // 创建一个空白缓冲区给Reader对象操作
    	readObj := bufio.NewReader(readBuf)   // 创建一个Reader对象
    	writeBuf := bytes.NewBuffer(nil)      // 创建一个空白缓冲区给Writer对象操作
    	writeObj := bufio.NewWriter(writeBuf) // 创建一个Writer对象
    	// 创建ReadWriter对象，该对象同时具备Reader对象和Writer对象的所有方法
    	readWriteObj := bufio.NewReadWriter(readObj, writeObj)
    	// 使用ReadWriter对象的写方法
    	readWriteObj.Write([]byte("写对象"))
    	readWriteObj.Flush()
    	fmt.Println(string(writeBuf.Bytes()))
    	// 使用ReadWriter对象的读方法
    	readBuf.Write([]byte("读对象"))
    	var readData [11]byte
    	readObj.Read(readData[:])
    	fmt.Println(string(readData[:]))
    }
    //写对象
    //读对象

[http_c.biancheng.net_view_5569.html]: http://c.biancheng.net/view/5569.html
[https_blog.csdn.net_windeal3203_article_details_79083453]: https://blog.csdn.net/windeal3203/article/details/79083453
[https_blog.csdn.net_Jiangtagong_article_details_108703123]: https://blog.csdn.net/Jiangtagong/article/details/108703123