go中的读写

其实go标准库中不少工具包都有各自涉及io操作的实现，但是归根到底还是基于io包的几个底层io接口，如io.Reader、io.byteReader等。其中：

io包主要提供了底层字节流io接口。

io/ioutil包提供了针对文件读写的io接口。

strings包提供了针对字符串的简单io接口。

gzip包实现了编解码的io接口。

crypto/cipher包也提供了加密用的io接口。

os包提供了平台无关的操作系统的接口，包括文件io。

基本io接口

io.Reader:

文件读写是最基本的底层能力，go的标准包io定义了一个Reader接口，只包含一个Read方法：

type Reader interface {
        Read(p []byte) (n int, err error)
}

就跟node中通过buffer一次次中转数据流一样，Read方法接收一个byte类型切片(相当于buffer)，长度由用户定义。

该方法每次读取len(p)字节的数据，并返回整数n和err实例。n的值为每次读取的字节数。

假如我要读的字符串长为14，传入的切片p长度为8，则：

第一次执行Read方法会读满8字节，并返回8,<nil>。

第二次执行read方法只会读取剩下的6个字节，剩余的填充0，返回6,<nil>。

第三次执行Read方法会返回0，EOF。这个EOF的错误用来告诉我们文件已读取完毕。

一个A Tour of Go的示例如下：

package main
import (
	"fmt"
	"io"  //io包提供一个EOF，等价于main中文件读取完时返回的err.EOF
	"strings"
)
func main() {
    //strings.NewReader返回一个类型，该类型保存接收的字符串并实现了Read方法
	r := strings.NewReader("Hello, Reader!")
	b := make([]byte, 8)
    //通过for循环不断读取Reader中的数据
	for {
		n, err := r.Read(b)
		fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
		fmt.Printf("b[:n] = %q\n", b[:n])
				if err == io.EOF {
			break
		}
	}
}
//输出：
n = 8 err = <nil> b = [72 101 108 108 111 44 32 82]
b[:n] = "Hello, R"
n = 6 err = <nil> b = [101 97 100 101 114 33 32 82]
b[:n] = "eader!"
n = 0 err = EOF b = [101 97 100 101 114 33 32 82]
b[:n] = ""

上边通过一个for循环一直执行Read方法，直到字符串读取完。此时再执行一次Read方法，会返回EOF错误告知你已经读取到文件末尾了。

io.Writer:

有io.Reader当然也有io.Writer:

type Writer interface {
        Write(p []byte) (n int, err error)
}

同io.Read，Write方法每次将len(p)个字节写入指定的数据流中。当n<len(p)时返回error告知文件已写完。

----分界线呀分界线---

其实go标准io包中定义了一堆基本io接口，之所以着重提上面两个接口，是因为go的标准库里，许多读写、操作文件相关工具函数，都是基于这两个接口的实现，包括gzip、io、strings、os等等。所以熟知这两个接口对理解标准库工具的实现非常有用！！！

(今天看源码看到眼睛疼，哭。。)

 

下边是展开的探讨》》》

高级接口设计

前边介绍io.Read的示例代码中有这两行:

import (
    "strings"
) 
...  
    //strings.NewReader接收一个字符串并创建一个reader对象
    r := strings.NewReader("Hello, Reader!")

strings是一个字符串工具包，其中strings.NewReader用于创建一个Reader类型实例，其源码很简单：

//定义一个strings包自己的Reader类型
type Reader struct {
	s        string
	i        int64 // current reading index
	prevRune int   // index of previous rune; or < 0
}
...
//对io.Reader接口的实现
func (r *Reader) Read(b []byte) (n int, err error) {
	if r.i >= int64(len(r.s)) {
		return 0, io.EOF
	}
	r.prevRune = -1
	n = copy(b, r.s[r.i:])
	r.i += int64(n)
	return
}
...
//对外暴露一个NewReader方法，该方法返回一个Reader类型的实例的指针
func NewReader(s string) *Reader { return &Reader{s, 0, -1} }

在strings包里，只是自定义一个Reader类型，并给该类型实现Reader接口。

但标准库中更普遍的io接口实现模式是(以Reader为例)：

0.定义一个模块自己的Reader类型。

1.该自定义类型接收一个io.Reader实例作为自己的一个字段。

2.给该自定义类型实现高级的读写接口。

3.定义一个函数，接收一个io.Reader实例并返回一个自定义Reader类型实例。

比如下面是gzip.NewReader对Reader的实现：

//Reader的r字段挂载一个flate.Reader接口
//flate.Reader接口是{io.reader,io.ByteReader}组合接口
type Reader struct {
	Header       // valid after NewReader or Reader.Reset
	r            flate.Reader
	decompressor io.ReadCloser
    ...
}
//接收一个底层的Reader接口，挂载到自定义Reader类型内部，并返回该类型
func NewReader(r io.Reader) (*Reader, error) {}
//给自定义类型实现一个Reader接口
func (z *Reader) Read(p []byte) (n int, err error) {}

gzip.NewWriter也是类似的实现。

先看看gzip的使用，这里引用stackoverflow的举例：

// use something like this to compress:
var b bytes.Buffer
w := gzip.NewWriter(&b)
w.Write([]byte("hello, world\n"))
w.Close()
...
//And this to unpack:
r, err := gzip.NewReader(&b)
io.Copy(os.Stdout, r)
r.Close()

可以看到，使用标准包的gzip压缩/解压文件时，也是创建一个Writer/Reader类型来处理数据。

我们只需要关注前两行代码。

第一行定义的bytes.Buffer类型，我看了下源码，是实现了Writer接口的,即变量b是一个io.Writer。

func (b *Buffer) Write(p []byte) (n int, err error) {
	b.lastRead = opInvalid
	m, ok := b.tryGrowByReslice(len(p))
	if !ok {
		m = b.grow(len(p))
	}
	return copy(b.buf[m:], p), nil
}

然后我们看看gzip的源码：

预定义一些压缩相关的常量：

const (
	NoCompression      = flate.NoCompression
	BestSpeed          = flate.BestSpeed
	BestCompression    = flate.BestCompression
	DefaultCompression = flate.DefaultCompression
	HuffmanOnly        = flate.HuffmanOnly
)

然后定义一个gzip自己的Writer类型 

//  w用来保存传入的io.Writer
//  其他是一些和压缩相关的标记常量
type Writer struct {
	Header      // written at first call to Write, Flush, or Close
	w           io.Writer
	level       int
	wroteHeader bool
	compressor  *flate.Writer
	digest      uint32 // CRC-32, IEEE polynomial (section 8)
	size        uint32 // Uncompressed size (section 2.3.1)
	closed      bool
	buf         [10]byte
	err         error
}

对外暴露一个gzip.NewWriter方法：

//DefaultCompression是gzip预定义的一个表示压缩值的整数
func NewWriter(w io.Writer) *Writer {
	z, _ := NewWriterLevel(w, DefaultCompression) 
	return z
}

这个方法把我们传给gzip.NewWriter的byte.Buffer传给另一个函数NewWriterLevel，并返回一个实例z。

我们看看NewWriterLevel做了什么：

func NewWriterLevel(w io.Writer, level int) (*Writer, error) {
	if level < HuffmanOnly || level > BestCompression {
		return nil, fmt.Errorf("gzip: invalid compression level: %d", level)
	}
	z := new(Writer)
	z.init(w, level)
	return z, nil
}

它new了一个Writer类型作为z返回。所以z也就是这个东西：

type Writer struct {
    Header      // written at first call to Write, Flush, or Close
    w           io.Writer
    level       int
    ....
}

然后这个gzip.Writer类型也实现了io.Writer接口：

func (z *Writer) Write(p []byte) (int, error) {
	if z.err != nil {
		return 0, z.err
	}
	var n int
	// Write the GZIP header lazily.
	if !z.wroteHeader {
	    ...
	}
//更新压缩相关的标记量
	z.size += uint32(len(p))
	z.digest = crc32.Update(z.digest, crc32.IEEETable, p)
//压缩后返回(int, error)
	n, z.err = z.compressor.Write(p)
	return n, z.err
}

go的io包里有个专门的ioutil包，提供了一些针对文件操作的函数，如ReadFile等，看了下其源码，最终还是用了bytes包的buffer类型的read方法，这个Read方法正是对io.Reader接口的实现。

 

事实上，go的标准库都遵循了统一的风格，或者说做了一样的事情：

*定义接口

*定义类型并为之添加方法

*对外暴露某些函数，而这些函数要么执行特定运算要么返回某个自定义类型

 

以至于我觉得，如果我们要构建自己的go库，我们只要遵循同样的方式即可，好清爽。。。

go标准库那一堆包，看到我头疼。但是看多了之后发现go还是蛮简洁的。。。至少比js的好看多了