golang ioutil与io包详解

ioutilio错误变量接口结构体函数 前提概要，公共错误处理

func checkErr(err error) { if err != nil { log.Fatil(err) } }

输出文件目录 file1.txt中的内容为1行 1：街角魔族是最好看的动漫！ file2.txt中的内容为2行 2：街角魔族是最好看的动漫！ 还有一个输入文件夹in，不过是空的就不截图了，到时候底下的例子凡是关于write的都是放进in文件夹里。

ioutil

首先就从最简单的ioutil开始把。 先申明，ioutil的所有方法我仅举例子并说明方法的用处，至于返回值或函数传参，凡是关于io属性与os属性的详细用法请自行往下查找io相关内容或os相关博文。

1、NopCloser(r io.Reader) io.ReadCloser用一个无操作的Close方法包装r返回一个ReadCloser接口。

//打开文件 file, err := os.Open("./out/file1.txt") checkErr(err) //通过io.Reader获得一个io.ReadCloser readCloser := ioutil.NopCloser(file)

注意这里的Close没有实际操作，源码如下⬇

func (nopCloser) Close() error { return nil }

2、ReadAll(r io.Reader) ([]byte, error)从r读取数据直到EOF或遇到error，返回读取的数据和可能的错误。成功的调用返回的err为nil而非EOF。因为本函数定义为读取r直到EOF，它不会将读取返回的EOF视为应报告的错误。

file, err := os.Open("./out/file1.txt") checkErr(err) fileBytes, err := ioutil.ReadAll(file) checkErr(err) fmt.Println(string(fileBytes))

正确的输出：

1：街角魔族是最好看的动漫！

3、ReadFile(filename string) ([]byte, error)从filename指定的文件中读取数据并返回文件的内容。对err的判断和ReadAll一样。

fileBytes, err := ioutil.ReadFile("./out/file2.txt") checkErr(err) fmt.Println(string(fileBytes))

输出

2：街角魔族是最好看的动漫！ 2：街角魔族是最好看的动漫！

4、WriteFile(filename string, data []byte, perm os.FileMode) error函数向filename指定的文件中写入数据。如果文件不存在将按给出的perm权限创建文件，否则在写入数据之前清空文件。

fileBytes, err := ioutil.ReadFile("./out/街角魔族1.jpg") checkErr(err) //以全权限写文件 ioutil.WriteFile("./in/街角魔族1.jpg", fileBytes, 0777)

输出效果，没有字节损失，依旧如此高清可爱，完美。 5、ReadDir(dirname string) ([]os.FileInfo, error)读取dirname目录内的所有文件信息，注意此序列有序。

osFiles, err := ioutil.ReadDir("./out") if err != nil { println(err) return } for i, osFile := range osFiles { //打印下标和文件名 fmt.Println(i, osFile.Name()) }

输出：

0 file1.txt 1 file2.txt 2 理直气壮.jpg 3 街角魔族1.jpg 4 街角魔族2.png

6、TempDir(dir, prefix string) (name string, err error)在dir目录里创建一个新的、使用prfix作为前缀的临时文件夹，并返回文件夹的路径。如果dir是空字符串，TempDir使用默认用于临时文件的目录（参见os.TempDir函数）。 不同程序同时调用该函数会创建不同的临时目录，调用本函数的程序有责任在不需要临时文件夹时摧毁它。

name, err := ioutil.TempDir("./in", "temp") checkErr(err) fmt.Println("已创建文件夹,目录：" + name) //等待1秒后删除创建的临时文件夹 time.Sleep(time.Second) err = os.Remove(name) checkErr(err) fmt.Println("已删除文件夹,目录：" + name)

输出：

已创建文件夹,目录：in\temp103398839 已删除文件夹,目录：in\temp103398839

7、TempFile(dir, prefix string) (f *os.File, err error)在dir目录下创建一个新的、使用prefix为前缀的临时文件，以读写模式打开该文件并返回os.File指针。如果dir是空字符串，TempFile使用默认用于临时文件的目录（参见os.TempDir函数）。责任与TempDir相同。

//在./in目录中创建一个前缀为temp,后缀为.png的临时文件 filePoint, err := ioutil.TempFile("./in", "temp*.png") checkErr(err) fmt.Println("已创建临时文件：目录", filePoint.Name()) fileBytes, err := ioutil.ReadFile("./out/街角魔族2.png") checkErr(err) _, err = filePoint.Write(fileBytes) //关闭文件流，不关将无法删除。 filePoint.Close() //等待10秒后删除创建的临时文件夹,文件留10秒截个效果图 time.Sleep(10 * time.Second) err = os.Remove(filePoint.Name()) checkErr(err) fmt.Println("已删除临时文件,目录", filePoint.Name())

结果非常perfect，高清可爱。

已创建临时文件：目录 in\temp224024071.png 已删除临时文件,目录 in\temp224024071.png

好了到这里outil的所有内容都已经写完了，有没有发现ioutil的方法往往只需要一句，并不需要其他语句就能完成功能，非常简洁明了。毕竟ioutil包的创建初衷就只是对io包实用功能的二次封装而已，同样的由于高度的封装，是不是对里面很多参数都很懵逼呢，如：perm os.FileMode，io.ReadCloser，io.Reader这种，感兴趣的话就接着看吧。

io

io包提供了对I/O原语的基本接口。本包的基本任务是包装这些原语已有的实现（如os包里的原语），使之成为共享的公共接口，这些公共接口抽象出了泛用的函数并附加了一些相关的原语的操作，非并发安全包。 原语：计算机进程的控制通常由原语完成。所谓原语，一般是指由若干条指令组成的程序段，用来实现某个特定功能，在执行过程中不可被中断。

错误变量

首先来看看包中的错误变量⬇ var EOF = errors.New(“EOF”) 正常输入结束Read返回EOF，如果在一个结构化数据流中EOF在不期望的位置出现了，则应返回错误ErrUnexpectedEOF或者其它给出更多细节的错误。

var ErrClosedPipe = errors.New(“io: read/write on closed pipe”) 当从一个已关闭的Pipe读取或者写入时，会返回ErrClosedPipe。

var ErrNoProgress = errors.New(“multiple Read calls return no data or error”) 某些使用io.Reader接口的客户端如果多次调用Read都不返回数据也不返回错误时，就会返回本错误，一般来说是io.Reader的实现有问题的标志。

var ErrShortBuffer = errors.New(“short buffer”) ErrShortBuffer表示读取操作需要大缓冲，但提供的缓冲不够大。

var ErrShortWrite = errors.New(“short write”) ErrShortWrite表示写入操作写入的数据比提供的少，却没有显式的返回错误。

var ErrUnexpectedEOF = errors.New(“unexpected EOF”) ErrUnexpectedEOF表示在读取一个固定尺寸的块或者数据结构时，在读取未完全时遇到了EOF。

接口

1、

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

一个Reader接口，只要是实现了Read方法的结构体都代表实现了Reader接口，os的很多关于file的结构体都是实现了Reader接口。想要实现Reader接口非常简单，只要实现了Read方法即可。 Read方法读取len§字节数据写入p。它返回写入的字节数和遇到的任何错误。 很多时候我们也可以通过自己实现Reader接口来给需要io.Reader 传参的函数使用，举个例子。

func main(){ //实例化一个实现了io.Reader接口的结构体 rs := ReaderStruct{"街角魔族是最好看的动漫!"} //实例化一个text长度的[]byte buf := make([]byte, len(rs.text)) //将rs读取至buf，返回长度 n, err := io.ReadFull(rs, buf) checkErr(err) fmt.Println(string(buf)) fmt.Println(n) } type ReaderStruct struct { text string } //实现Reader接口中的Read方法,总的功能就是将ReaderStruct中的text属性读取出来 func (rs ReaderStruct) Read(p []byte) (n int, err error) { bf := bytes.NewBufferString(rs.text) bytes := bf.Bytes() i := 0 for i < len(p) { p[i] = bytes[i] i++ } n = len(p) err = io.EOF return n, err }

输出

街角魔族是最好看的动漫! 34

是不是很简单呢，对于字符操作有不懂的可以看这篇文章

2、

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

Writer接口用于包装基本的写入方法。 Write方法len( p )字节数据从p写入底层的数据流。它会返回写入的字节数(0 <= n <= len( p ))和遇到的任何导致写入提取结束的错误。Write必须返回非nil的错误，如果它返回的 n < len( p )。Write不能修改切片p中的数据，即使临时修改也不行。

func main(){ //此处的buf为上一个例子Reader代码中实例化并赋值的 buffer := bytes.NewBuffer(buf) ws := WriterStruct{} //将buffer中的buf写入ws buffer.WriteTo(&ws) fmt.Println("writerStruct.bytes:", string(ws.bytes)) } type WriterStruct struct { bytes []byte } func (ws *WriterStruct) Write(p []byte) (int, error) { ws.bytes = append(ws.bytes, p...) return len(p), nil }

这个例子要和上一个例子结合着看，里面的buf在上一个例子中有读ReaderStruct里的text值并赋值至buf。 输出：

writerStruct.bytes: 街角魔族是最好看的动漫!

3、

type Closer interface { Close() error }

Closer接口用于包装基本的关闭方法。 在第一次调用之后再次被调用时，Close方法的的行为是未定义的。某些实现可能会说明他们自己的行为。 在整个标准库内都没有对Closer的引用，只有实现，因此这个就不举例了，用法都是开启某某连接/流，在用完/报错后在进行Close的操作。

4、

type Seeker interface { Seek(offset int64, whence int) (int64, error) }

Seeker接口用于包装基本的移位方法。 Seek方法设定下一次读写的位置：偏移量为offset，校准点由whence确定：0表示相对于文件起始；1表示相对于当前位置；2表示相对于文件结尾。Seek方法返回新的位置以及可能遇到的错误。 移动到一个绝对偏移量为负数的位置会导致错误。移动到任何偏移量为正数的位置都是合法的，但其下一次I/O操作的具体行为则要看底层的实现。 在整个标准库内都没有对Seeker的引用，只有实现，因此这个就不举例了。

5、

type ReadCloser interface { Reader Closer }

见名知意，就是Reader+Closer，例如在ioutil中的NopCloser方法返回的就是一个ReadCloser，但是里面的Close就是个空函数，毫无作用。

6、

type ReadSeeker interface { Reader Seeker }

ReadSeeker接口聚合了基本的读取和移位操作。

7、

type WriteCloser interface { Writer Closer }

WriteCloser接口聚合了基本的写入和关闭操作。

8、

type WriteSeeker interface { Writer Seeker }

WriteSeeker接口聚合了基本的写入和移位操作。

9、

type ReadWriter interface { Reader Writer }

ReadWriter接口聚合了基本的读写操作。

10、

type ReadWriteCloser interface { Reader Writer Closer }

ReadWriteCloser接口聚合了基本的读写和关闭操作。

11、

type ReadWriteSeeker interface { Reader Writer Seeker }

ReadWriteSeeker接口聚合了基本的读写和移位操作

12、

type ReaderAt interface { ReadAt(p []byte, off int64) (n int, err error) }

ReaderAt接口包装了的ReadAt方法。

ReadAt从底层输入流的偏移量off位置读取len( p )字节数据写入p， 它返回读取的字节数(0 <= n <= len( p ))和遇到的任何错误。

当ReadAt返回n<len( p )时，它返回一个非零错误，解释为什么没有返回更多的字节。在这方面，Readat比Read更严格。

即使ReadAt方法返回值 n < len( p )，它在被调用时仍可能使用p的全部长度作为暂存空间。如果有部分可用数据，但不够len( p )字节，ReadAt会阻塞直到获取len( p )个字节数据或者遇到错误。在这方面，ReadAt和Read是不同的。

如果ReadAt返回的n=len( p )字节位于输入源的末尾，那么ReadAt可以返回err== EOF或err ==nil。

如果ReadAt是从某个有偏移量的底层输入流（的Reader包装）读取，ReadAt方法既不应影响底层的偏移量，也不应被底层的偏移量影响。

ReadAt的调用者可以对同一个输入源执行并行ReadAt调用。实现不能保留p。

13、

type WriterAt interface { WriteAt(p []byte, off int64) (n int, err error) }

WriterAt接口包装了基本的WriteAt方法。

在偏移结束时，WriteAt将len§字节从p写入基础数据流。它返回从p(0<=n<=len§)写入的字节数以及导致写入提前停止的任何错误。如果写入错误返回n<len§，则必须返回非零错误。

如果WriteAt使用查找偏移量写入目标，则WriteAt不应影响也不受基础查找偏移量的影响。

如果写入范围不重叠，WriteAt的调用方可以在同一目标上执行并行WriteAt调用。实现不能保留p。

14、

type ByteReader interface { ReadByte() (c byte, err error) }

ByteReader是基本的ReadByte方法的包装。

ReadByte读取输入中的单个字节并返回。如果没有字节可读取，会返回错误。

15、

type ByteReader interface { ReadByte() (c byte, err error) }

ByteReader是基本的ReadByte方法的包装。

ReadByte读取输入中的单个字节并返回。如果没有字节可读取，会返回错误。

16、

type ByteScanner interface { ByteReader UnreadByte() error }

ByteScanner接口在基本的ReadByte方法之外还添加了UnreadByte方法。

UnreadByte方法让下一次调用ReadByte时返回之前调用ReadByte时返回的同一个字节。连续调用两次UnreadByte方法而中间没有调用ReadByte时，可能会导致错误。

17、

type ByteWriter interface { WriteByte(c byte) error }

ByteWriter是包装WriteByte方法的接口。

18、

type RuneReader interface { ReadRune() (r rune, size int, err error) }

RuneReader是基本的ReadRune方法的包装。

ReadRune读取单个utf-8编码的字符，返回该字符和它的字节长度。如果没有有效的字符，会返回错误。

19、

type RuneScanner interface { RuneReader UnreadRune() error }

RuneScanner接口在基本的ReadRune方法之外还添加了UnreadRune方法。

UnreadRune方法让下一次调用ReadRune时返回之前调用ReadRune时返回的同一个utf-8字符。连续调用两次UnreadRune方法而中间没有调用ReadRune时，可能会导致错误。

20、

type ReaderFrom interface { ReadFrom(r Reader) (n int64, err error) }

ReaderFrom是包装ReadFrom方法的接口。

ReadFrom方法从r读取数据直到EOF或者遇到错误。返回值n是读取的字节数，执行时遇到的错误（EOF除外）也会被返回。

21、

type WriterTo interface { WriteTo(w Writer) (n int64, err error) }

WriterTo是包装WriteTo方法的接口。

WriterTo写入数据到w，直到没有更多的数据要写入或发生错误时。返回值n是写入的字节数。还将返回写入过程中遇到的任何错误。如果可用，复制函数将使用WriterTo。

以上就是io包全部的21个公共接口了。

结构体

1、

type LimitedReader struct { R Reader // underlying reader N int64 // max bytes remaining }

LimitedReader从R读取，但将返回的数据量限制为N个字节。每次读取更新N以标记剩余可以读取的字节数。Read在N<=0时或基础R返回EOF时返回EOF。 具体实现方法有： 1）func (l *LimitedReader) Read(p []byte) (n int, err error) Reader接口的实现方法

r := strings.NewReader("街角魔族是最好看的动漫！") //限制27字节，只读取9字 n := int64(27) limitReader := io.LimitReader(r, n) bs := make([]byte, n) _, err := lr.Read(bs) checkErr(err) fmt.Println(string(bs))

输出：

街角魔族是最好看的

2、

type PipeReader struct { // 内含隐藏或非导出字段 }

PipeReader是一个管道的读取端。 具体实现方法有： 1）func (r *PipeReader) Read(data []byte) (n int, err error) Read实现了标准的读取接口：它从管道中读取数据，阻塞直到写入端到达或写入端被关闭。如果用错误关闭写入端，则返回错误为ERR；否则ERR为EOF。

2）func (r *PipeReader) Close() error Close关闭读取器；关闭后如果对管道的写入端进行写入操作，就会返回(0, ErrClosedPip)。

3）func (r *PipeReader) CloseWithError(err error) error CloseWithError类似Close方法，但将调用Write时返回的错误改为err。

3、

type PipeWriter struct { // 内含隐藏或非导出字段 }

PipeWriter是一个管道的写入端。 具体实现方法有： 1）func (w *PipeWriter) Write(data []byte) (n int, err error) Write实现了标准的写接口：它将数据写入管道，直到一个或多个读取端消耗完所有数据或读取端关闭为止。如果以错误关闭读取端，则该错误将作为ERR返回；否则ERR将为ErrClosedPipe。

2）func (w *PipeWriter) Close() error Close关闭写入器；关闭后如果对管道的读取端进行读取操作，就会返回(0, EOF)。

3）func (w *PipeWriter) CloseWithError(err error) error CloseWithError类似Close方法，但将调用Read时返回的错误改为err。

注：以上两个结构体PipeWriter与PipeReader是结合使用的需要用Pipe()方法进行创建。

创建函数func Pipe() (*PipeReader, *PipeWriter) Pipe创建一个同步的内存管道。 可用于连接期望io.Reader的代码和期望io.Writer的代码。

管道上的读和写是一对一匹配的，除非需要多次读取才能使用单次写入。也就是说，每次对PipeWriter的写入都将阻塞，直到它满足从PipeReader读取的一个或多个读取，这些读取会完全消耗已写入的数据。

数据直接从Write复制到相应的Read (或Reads)；没有内部缓冲。 对读的并行调用和对写的并行调用也是安全的：单个调用将按顺序执行。 举个例子⬇

r, w := io.Pipe() //开启写协程 go func() { for i := 0; i < 3; i++ { buf := bytes.NewBufferString("街角魔族是最好看的动漫！\n") w.Write(buf.Bytes()) } w.Close() }() str := strings.Builder{} bs := make([]byte, 37) //循环读取直至读取结束EOF或其他错误 for { _, err := r.Read(bs) if err != nil { break } str.Write(bs) } r.Close() fmt.Println(str.String())

输出：

街角魔族是最好看的动漫！ 街角魔族是最好看的动漫！ 街角魔族是最好看的动漫！

值得注意的是在没有读取完Writer写入的内容前，主协程main是完全阻塞的，上面的writer如果换一个其他的比如strings.Builder.WriteString()连协程都进不去，主协程就执行完毕了。

4、

type SectionReader struct { // contains filtered or unexported fields }

SectionReader在ReaderAt的基础上实现了Read，Seek和ReadAt。 具体实现方法有：

1）func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader 结构体SectionReader的创建方法 NewSectionReader返回一个SectionReader，它从r开始读取，偏移量为off，并在n个字节后以EOF停止。

2）func (s *SectionReader) Read(p []byte) (n int, err error) 实现了接口Reader的Read方法

3）func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error) 实现了接口ReaderAt的ReadAt方法

4）func (s *SectionReader) Seek(offset int64, whence int) (int64, error) 实现了接口Seeker的Seek方法 func (*SectionReader) Size

5）func (s *SectionReader) Size() int64 Size返回以字节为单位的片段大小。 举个例子⬇

//SectionReader Method NewReader r := strings.NewReader("真言：街角魔族是最好看的动漫！") s := io.NewSectionReader(r, 9, 33) fmt.Println("原Reader内容：", *r) fmt.Printf("创建SectionReader,跳过%d个字节读取%d个字节\n", 9, 33) ReadBytes := make([]byte, r.Len()) //SectionReader Method Read s.Read(ReadBytes) fmt.Println("Read:", string(ReadBytes)) //SectionReader Method ReadAt //s中的内容为 街角魔族是最好看的动漫 var off int64 off = 15 //注意bs的长度不能大于s.Size()-off,此值为最大值，大于将报错 ReadAtBytes := make([]byte, s.Size()-off) //从off的位置开始读取s中的内容存进bs n, err := s.ReadAt(ReadAtBytes, off) checkErr(err) fmt.Println("ReadAt:", string(ReadAtBytes), n) //SectionReader Method seek //在下一次的读写操作中设置相对于whence的偏移量offset //返回相对于文件开头的新偏移量n与可能的错误 //具体请看文章type Seeker的描述 n64, err := s.Seek(6, io.SeekStart) checkErr(err) fmt.Printf("从%d开始读6字节\n", n64) buf := make([]byte, 6) _, err = s.Read(buf) checkErr(err) fmt.Println("经过seek的Read", string(buf), n64) //注意这里的ReadAt是从第3字节开始读的，如果受seek偏移量的影响 //那么应该是，从 '族'开始，但ReadAt并不受偏移量影响所以从'角'开始读 _, err = s.ReadAt(buf, 3) checkErr(err) fmt.Println("经过seek的ReadAt", string(buf))

输出：

原Reader内容： {真言：街角魔族是最好看的动漫！ 0 -1} 创建SectionReader,跳过9个字节读取33个字节 Read: 街角魔族是最好看的动漫 ReadAt: 最好看的动漫 18 从6开始读6字节 经过seek的Read 魔族 6 经过seek的ReadAt 角魔

可以看的出来为什么说SectionReader是根据ReaderAt实现的而非Seeker了，虽然两者的效果很像，但是ReaderAt读取内容是无视Seeker偏移量的。且在读取数据大小上ReadAt是要比Read严格的，同样的Bytes在Read上即使设大了也会没事，但在ReadAt会报错。 其实上面说的关于ReadAt的两个注意点在我写的ReaderAt接口的描述中都有说明，但怕你们没注意在举例上实验一遍，还有几个需要注意的点我没举例子实验，你们感兴趣可以往上翻看看ReaderAt接口的描述。 以上就是io包全部的4个公共结构体了。

函数

1、Copy(dst Writer, src Reader) (written int64, err error) 将副本从src复制到dst，直到在src上达到EOF或发生错误。它返回复制的字节数和复制时遇到的第一个错误（如果有）。 成功的复制将返回err == nil而不是err == EOF。因为复制被定义为从src读取直到EOF，所以它不会将读取的EOF视为要报告的错误。 如果src实现WriterTo接口，则通过调用src.WriteTo（dst）实现该副本。否则，如果dst实现了ReaderFrom接口，则通过调用dst.ReadFrom（src）实现该副本。

r := strings.NewReader("街角魔族是世界上最好看的动漫!") w := new(strings.Builder) //通过r.WriteTo()实现该副本 written, err := io.Copy(w, r) checkErr(err) fmt.Println(w.String(), written)

输出：

街角魔族是世界上最好看的动漫! 43

2、func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) CopyBuffer与Copy相同，区别在于CopyBuffer逐步遍历提供的缓冲区（如果需要），而不是分配临时缓冲区。如果buf为nil，则分配一个；如果长度为零，则CopyBuffer会panic报错。 如果src实现WriterTo或dst实现ReaderFrom，则buf将不用于执行复制。

r := strings.NewReader("街角魔族是世界上最好看的动漫!") w := new(strings.Builder) //如果len(buf)==0会报错 written, err := io.CopyBuffer(w, r, make([]byte, 9)) checkErr(err) fmt.Println(w.String(), written)

输出：

街角魔族是世界上最好看的动漫! 43

3、func CopyN(dst Writer, src Reader, n int64) (written int64, err error) CopyN将n个字节（或直到出错）从src复制到dst。它返回复制的字节数以及复制时遇到的最早错误。返回时，只有err == nil时，writte == n。 如果dst实现了ReaderFrom接口，则使用该接口实现副本。

r := strings.NewReader("街角魔族是世界上最好看的动漫!") w := new(strings.Builder) //如果n大于len(r)会报错 written, err := io.CopyN(w, r, 36) checkErr(err) fmt.Println(w.String(), written)

输出：

街角魔族是世界上最好看的 36

4、func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) ReadAtLeast从r读取到buf，直到它至少读取了min字节。它返回复制的字节数n，如果读取的字节数少则返回错误。仅当未读取任何字节时，错误才是EOF。如果在读取少于最小字节后发生EOF，则ReadAtLeast返回ErrUnexpectedEOF。如果min大于buf的长度，则ReadAtLeast返回ErrShortBuffer。返回时，当且仅当err == nil时，n> = min。

r := strings.NewReader("街角魔族是最好看的动漫!") //min如果大于len(r)会报错 min := 27 //这边buf的len如果小于min也会报错 buf := make([]byte, min) n, err := io.ReadAtLeast(r, buf, min) checkErr(err) fmt.Println(string(buf), n)

输出：

街角魔族是最好看的 27

5、func ReadFull(r Reader, buf []byte) (n int, err error) ReadFull将r中的len（buf）个字节准确地读取到buf中。它返回复制的字节数，如果读取的字节数少则返回错误。仅当未读取任何字节时，错误才是EOF。如果在读取了一些但不是全部字节后发生EOF，则ReadFull返回ErrUnexpectedEOF。返回时，当且仅当err == nil时，n == len（buf）。

r := strings.NewReader("街角魔族是最好看的动漫！") buf := make([]byte, 12) _, err := io.ReadFull(r, buf) checkErr(err) fmt.Println(string(buf)) //buf大于io.Reader时,Err=EOF longBuf := make([]byte, 100) _, err = io.ReadFull(r, longBuf) checkErr(err)

输出：

街角魔族 2020/07/14 16:22:27 unexpected EOF

6、func WriteString(w Writer, s string) (n int, err error) WriteString将字符串s的内容写入w，w接收一个字节切片。如果w实现了StringWriter，则直接调用其WriteString方法。否则，w.Write只会被调用一次。

io.WriteString(os.Stdout, "街角魔族是世界上最好看的动漫！")

输出：

街角魔族是世界上最好看的动漫！

7、func LimitReader(r Reader, n int64) Reader LimitReader返回一个从r读取但在n字节后以EOF停止的Reader。 基础实现是一个* LimitedReader。 例子在结构体1写了，很简单就不再重复了。

8、func MultiReader(readers ...Reader) Reader MultiReader返回一个Reader，它是所提供的输入阅读器的逻辑串联。它们被顺序读取。一旦所有输入均返回EOF，读取将返回EOF。如果任何读取器返回非零，非EOF错误，则Read将返回该错误。

r := strings.NewReader("街角魔族是最好看的动漫！") r2 := strings.NewReader("说得对") w := new(strings.Builder) mr := io.MultiReader(r, r2) n, err := io.Copy(w, mr) checkErr(err) fmt.Println(w.String(), n)

输出：

街角魔族是最好看的动漫！说得对 45

9、func TeeReader(r Reader, w Writer) Reader TeeReader返回一个Reader，该Reader向w写入从r读取的内容。通过r执行的所有r读取均与对w的相应写入匹配。没有内部缓冲-写入必须在读取完成之前完成。写入时遇到的任何错误均报告为读取错误。

r := strings.NewReader("街角魔族是最好看的动漫！") w := new(strings.Builder) tee := io.TeeReader(r, w) p := make([]byte, r.Len()) fmt.Println("读取前w：", w.String()) _, err := tee.Read(p) checkErr(err) fmt.Println("读取的值", string(p)) //所有对tee中的r io.Reader的读取都会往tee中的w io.Writer写入 fmt.Println("读取后w：", w.String())

输出：

读取前w： 读取的值 街角魔族是最好看的动漫！ 读取后w： 街角魔族是最好看的动漫！

10、func MultiWriter(writers ...Writer) Writer MultiWriter创建一个Writers，将其写入复制到所有提供的写入器中，类似于Unix tee（1）命令。 每个写入一次写入每个列出的写入器。如果列出的写程序返回错误，则整个写操作将停止并返回错误；它不会在列表中继续下去。

r := strings.NewReader("街角魔族是世界上最好看的动漫！") builder1 := new(strings.Builder) builder2 := new(strings.Builder) ws := io.MultiWriter(builder1, builder2) _, err := io.Copy(ws, r) checkErr(err) fmt.Print(builder1.String()) fmt.Print(builder2.String())

输出：

街角魔族是最好看的动漫！街角魔族是最好看的动漫！

以上就是io的全部的10个公共函数了 其实例子早就写完了，但是太忙一直没写博文，本来标题是 ioutil/io/bufio/os io流，文件操作大全，这几个一起用的相关度非常高，但是实在太忙没工夫写os和bufio了，等以后有机会吧。 以上结束。