Go io包
Go io包
秋风醉了 发表于1年前
Go io包
  • 发表于 1年前
  • 阅读 26
  • 收藏 0
  • 点赞 0
  • 评论 0

新睿云服务器60天免费使用,快来体验!>>>   

摘要: Go io包

Go io包

Go io包的接口概览

io.Writer interface

// Writer 接口包装了基本的 Write 方法,用于将数据存入自身。
// Write 方法用于将 p 中的数据写入到对象的数据流中,
// 返回写入的字节数和遇到的错误。
// 如果 p 中的数据全部被写入,则 err 应该返回 nil。
// 如果 p 中的数据无法被全部写入,则 err 应该返回相应的错误信息。
type Writer interface {
    Write(p []byte) (n int, err error)
}

我们可以通过查看标准库文档,列出实现了io.Reader或io.Writer接口的类型(导出的类型):

os.File 同时实现了io.Reader和io.Writer
strings.Reader 实现了io.Reader
bufio.Reader/Writer 分别实现了io.Reader和io.Writer
bytes.Buffer 同时实现了io.Reader和io.Writer
bytes.Reader 实现了io.Reader
compress/gzip.Reader/Writer 分别实现了io.Reader和io.Writer
crypto/cipher.StreamReader/StreamWriter 分别实现了io.Reader和io.Writer
crypto/tls.Conn 同时实现了io.Reader和io.Writer
encoding/csv.Reader/Writer 分别实现了io.Reader和io.Writer
mime/multipart.Part 实现了io.Reader

以bufio.Writer 为例,来看一下具体的使用方法,

package main

import (
	"bufio"
	"os"
	"fmt"
)

func main() {
	//func Copy(dst Writer, src Reader) (written int64, err error)
	path := "/Users/xinxingegeya/workspace-go/src/awesomeProject/io/hello.txt"
	fd, _ := os.OpenFile(path, os.O_RDWR|os.O_APPEND, 0666)

	// 实现一个带缓冲的写文件
	w := bufio.NewWriterSize(fd, 4096)

	fmt.Println(w.Available()) //表示可使用的缓冲区的大小
	fmt.Println(w.Buffered())  //表示已经缓冲的数据的大小

	w.WriteString("hello world!\n")

	w.Write([]byte("hello world!\n"))

	fmt.Println(w.Available()) //表示可使用的缓冲区的大小
	fmt.Println(w.Buffered())  //表示已经缓冲的数据的大小

	//此时需要刷新一下数据才能写入文件
	w.Flush()
}

 

io.Reader interface

// Reader 接口包装了基本的 Read 方法,用于输出自身的数据。
// Read 方法用于将对象的数据流读入到 p 中,返回读取的字节数和遇到的错误。
// 在没有遇到读取错误的情况下:
// 1、如果读到了数据(n > 0),则 err 应该返回 nil。
// 2、如果数据被读空,没有数据可读(n == 0),则 err 应该返回 EOF。
// 如果遇到读取错误,则 err 应该返回相应的错误信息。
type Reader interface {
    Read(p []byte) (n int, err error)
}

bufio.Reader 实现了该接口,其他的接口的实现请看上文,

package main

import (
	"bufio"
	"os"
	"fmt"
)

func main() {
	//func Copy(dst Writer, src Reader) (written int64, err error)
	path := "/Users/xinxingegeya/workspace-go/src/awesomeProject/io/hello.txt"
	fd, _ := os.OpenFile(path, os.O_RDWR|os.O_APPEND, 0666)

	rd := bufio.NewReaderSize(fd, 4096)

	fmt.Println(rd.Buffered()) //表示已经缓冲的数据的大小

	str, _ := rd.ReadString(byte('\n'))
	fmt.Println(str)
	fmt.Println(rd.Buffered()) //表示已经缓冲的数据的大小
}

 

io.WriterTo interface

// WriterTo 接口包装了基本的 WriteTo 方法,用于将自身的数据写入 w 中。
// 直到数据全部写入完毕或遇到错误为止,返回写入的字节数和遇到的错误。
type WriterTo interface {
    WriteTo(w Writer) (n int64, err error)
}

bufio.Reader 实现了该接口 ,使用示例如下,

package main

import (
	"bufio"
	"os"
	"fmt"
)

func main() {
	path := "/Users/xinxingegeya/workspace-go/src/awesomeProject/io/hello.txt"
	fd, _ := os.OpenFile(path, os.O_RDWR|os.O_APPEND, 0666)

	rd := bufio.NewReaderSize(fd, 4096)
	rd.ReadString(byte('\n'))
	fmt.Println(rd.Buffered()) //表示已经缓冲的数据的大小

	w := bufio.NewWriterSize(os.Stdout, 4096)
	rd.WriteTo(w) // WriteTo 方法实现了 io.WriterTo 接口
	fmt.Println(rd.Buffered())
	fmt.Println(w.Available())
	fmt.Println(w.Buffered())
	w.Flush()
}

 

io.ReaderFrom interface

// ReaderFrom 接口包装了基本的 ReadFrom 方法,用于从 r 中读取数据存入自身。
// 直到遇到 EOF 或读取出错为止,返回读取的字节数和遇到的错误。
type ReaderFrom interface {
    ReadFrom(r Reader) (n int64, err error)
}

bufio.Writer 实现了该接口,使用示例如下,

package main

import (
	"bufio"
	"os"
	"fmt"
)

func main() {
	path := "/Users/xinxingegeya/workspace-go/src/awesomeProject/io/hello.txt"
	fd, _ := os.OpenFile(path, os.O_RDWR|os.O_APPEND, 0666)

	rd := bufio.NewReaderSize(fd, 4096)
	rd.ReadString(byte('\n'))
	fmt.Println(rd.Buffered()) //表示已经缓冲的数据的大小

	w := bufio.NewWriterSize(os.Stdout, 4096)
	w.ReadFrom(rd)
	w.Flush()
}

 

io.Seeker interface

// Seeker 接口包装了基本的 Seek 方法,用于移动数据的读写指针。
// Seek 设置下一次读写操作的指针位置,每次的读写操作都是从指针位置开始的。
// whence 的含义:
// 如果 whence 为 0:表示从数据的开头开始移动指针。
// 如果 whence 为 1:表示从数据的当前指针位置开始移动指针。
// 如果 whence 为 2:表示从数据的尾部开始移动指针。
// offset 是指针移动的偏移量。
// 返回新指针位置和遇到的错误。
type Seeker interface {
    Seek(offset int64, whence int) (ret int64, err error)
}

strings.Reader 实现了 io.Seeker接口,

// A Reader implements the io.Reader, io.ReaderAt, io.Seeker, io.WriterTo,
// io.ByteScanner, and io.RuneScanner interfaces by reading
// from a string.
type Reader struct {
	s        string
	i        int64 // current reading index
	prevRune int   // index of previous rune; or < 0
}

// Seek implements the io.Seeker interface.
func (r *Reader) Seek(offset int64, whence int) (int64, error) {
	r.prevRune = -1
	var abs int64
	switch whence {
	case io.SeekStart:
		abs = offset
	case io.SeekCurrent:
		abs = r.i + offset
	case io.SeekEnd:
		abs = int64(len(r.s)) + offset
	default:
		return 0, errors.New("strings.Reader.Seek: invalid whence")
	}
	if abs < 0 {
		return 0, errors.New("strings.Reader.Seek: negative position")
	}
	r.i = abs
	return abs, nil
}

strings.Reader的使用示例,

package main

import (
	"strings"
	"io"
	"fmt"
)

func main() {
	rd := strings.NewReader("Hello World!")
	rd.Seek(6, io.SeekStart)
	data := make([]byte, 5)
	n, err := rd.Read(data)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(n)
	fmt.Println(string(data))
}

 

其他接口的概述

// ReaderAt 接口包装了基本的 ReadAt 方法,用于将自身的数据写入 p 中。
// ReadAt 忽略之前的读写位置,从起始位置的 off 偏移处开始读取。
//
// 返回写入的字节数和遇到的错误,如果 p 被写满,则 err 会返回 nil。如果 p 没
// 有被写满,则会返回一个错误信息用于说明为什么没有写满(比如 io.EOF)。在这
// 方面 ReadAt 比 Read 更严格。如果 p 被写满的同时,自身的数据也刚好被读完,
// 则 err 即可以返回 nil 也可以返回 io.EOF。
//
// 即使不能将 p 填满,ReadAt 在被调用时也可能会使用整个 p 的空间作为缓存空间。
// 如果 ReadAt 自身的数据是从其它地方(比如网络)获取数的,那么在写入 p 的时
// 候,如果没有把 p 写满(比如网络延时),则 ReadAt 会阻塞,直到获取更多的数
// 据把 p 写满,或者所有数据都获取完毕,或者遇到读取错误(比如超时)时才返回。
// 在这方面,ReadAt 和 Read 是不同的。
//
// 如果 ReadAt 读取的对象是某个有偏移量的底层数据流时,则 ReadAt 方法既不能影
// 响底层的偏移量,也不应该被底层的偏移量影响。
//
// ReadAt 的调用者可以对同一数据流并行执行 ReadAt 方法。
//
// ReaderAt 的实现者不应该持有 p。
type ReaderAt interface {
    ReadAt(p []byte, off int64) (n int, err error)
}

------------------------------

// WriterAt 接口包装了基本的 WriteAt 方法,用于将 p 中的数据写入自身。
// ReadAt 忽略之前的读写位置,从起始位置的 off 偏移处开始写入。
//
// 返回写入的字节数和遇到的错误。如果 p 没有被读完,则必须返回一个 err 值来说
// 明为什么没有读完。
//
// 如果 WriterAt 写入的对象是某个有偏移量的底层数据流时,则 ReadAt 方法既不能
// 影响底层的偏移量,也不应该被底层的偏移量影响。
//
// WriterAt 的调用者可以对同一数据流的不同区段并行执行 WriteAt 方法。
//
// WriterAt 的实现者不应该持有 p。
type WriterAt interface {
    WriteAt(p []byte, off int64) (n int, err error)
}

------------------------------

// ByteReader 接口包装了基本的 ReadByte 方法,用于从自身读出一个字节。
// 返回读出的字节和遇到的错误。
type ByteReader interface {
    ReadByte() (c byte, err error)
}

------------------------------

// ByteScanner 在 ByteReader 的基础上增加了一个 UnreadByte 方法,用于撤消最后
// 一次的 ReadByte 操作,以便下次的 ReadByte 操作可以读出与前一次一样的数据。
// UnreadByte 之前必须是 ReadByte 才能撤消成功,否则可能会返回一个错误信息(根
// 据不同的需求,UnreadByte 也可能返回 nil,允许随意调用 UnreadByte,但只有最
// 后一次的 ReadByte 可以被撤销,其它 UnreadByte 不执行任何操作)。
type ByteScanner interface {
    ByteReader
    UnreadByte() error
}

------------------------------

// ByteWriter 接口包装了基本的 WriteByte 方法,用于将一个字节写入自身
// 返回遇到的错误
type ByteWriter interface {
    WriteByte(c byte) error
}

------------------------------

// RuneReader 接口包装了基本的 ReadRune 方法,用于从自身读取一个 UTF-8 编码的
// 字符到 r 中。
// 返回读取的字符、字符的编码长度和遇到的错误。
type RuneReader interface {
    ReadRune() (r rune, size int, err error)
}

------------------------------

// RuneScanner 在 RuneReader 的基础上增加了一个 UnreadRune 方法,用于撤消最后
// 一次的 ReadRune 操作,以便下次的 ReadRune 操作可以读出与前一次一样的数据。
// UnreadRune 之前必须是 ReadRune 才能撤消成功,否则可能会返回一个错误信息(根
// 据不同的需求,UnreadRune 也可能返回 nil,允许随意调用 UnreadRune,但只有最
// 后一次的 ReadRune 可以被撤销,其它 UnreadRune 不执行任何操作)。
type RuneScanner interface {
    RuneReader
    UnreadRune() error
}

======END======

  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
粉丝 216
博文 605
码字总数 432178
×
秋风醉了
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: