这里系统介绍一下基本的IO接口，平常在看项目的时候会发现很多 Reader ，ReadAt，Write，WriteAt 类型，因此这次来系统学习，归纳一下

  • Reader + Write

    ==Reader==

    1
    2
    3
    4
    5
    6
    7
    8
    /* 
    Reader is the interface that wraps the basic Read method.

    Read reads up to len(p) bytes into p. It returns the number of bytes read (0 <= n <= len(p)) and any error encountered. Even if Read returns n < len(p), it may use all of p as scratch space during the call. If some data is available but not len(p) bytes, Read conventionally returns what is available instead of waiting for more.
    */
    type Reader interface{
    	Read(p []byte)(n int, err error)
    }

    将数据读取到切片p中，然后返回读取的字节和错误

    示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    func main() {
        // 创建一个字符串并使用strings.Reader读取
        data := "这是一段测试文本"
        reader := strings.NewReader(data)

        // 从reader中读取数据
        buf := make([]byte, 1024)
        n, err := reader.Read(buf)
        if err != nil {
            log.Println("读取数据失败", err)
        }
        fmt.Println("读取到", n, "字节的数据")
    }

    ==Write==

    1
    2
    3
    4
    5
    6
    7
    /* Writer is the interface that wraps the basic Write method.

    Write writes len(p) bytes from p to the underlying data stream. It returns the number of bytes written from p (0 <= n <= len(p)) and any error encountered that caused the write to stop early. Write must return a non-nil error if it returns n < len(p). Write must not modify the slice data, even temporarily.
    */
    type Writer interface {
        Write(p []byte) (n int, err error)
    }

    就是把p中的内容写入，这个方法的对象中

    示例

    1
    2
    3
    4
    5
    6
    7
    func Fprintln(w io.Writer, a ...any) (n int, err error) {
    	p := newPrinter()
    	p.doPrintln(a)
    	n, err = w.Write(p.buf)
    	p.free()
    	return
    }

  • ReaderAt + WriteAt

    这两个就是多了一个偏移量

    ==ReaderAt==

    1
    2
    3
    4
    5
    6
    /*
    ReadAt reads len(p) bytes into p starting at offset off in the underlying input source. It returns the number of bytes read (0 <= n <= len(p)) and any error encountered.
    */
    type ReaderAt interface {
        ReadAt(p []byte, off int64) (n int, err error)
    }

    示例

    1
    2
    3
    4
    5
    6
    7
    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)

    ==WriteAt==

    1
    2
    3
    4
    5
    6
    /*
    WriteAt writes len(p) bytes from p to the underlying data stream at offset off. It returns the number of bytes written from p (0 <= n <= len(p)) and any error encountered that caused the write to stop early. WriteAt must return a non-nil error if it returns n < len(p).
    */
    type WriterAt interface {
        WriteAt(p []byte, off int64) (n int, err error)
    }

    示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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)

  • ReaderFrom + WriterTo

    ==ReaderFrom==

    ReadFrom 从 r 中读取数据，直到 EOF 或发生错误。其返回值 n 为读取的字节数。除 io.EOF 之外，在读取过程中遇到的任何错误也将被返回。

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

    ==WriteTo==

    WriteTo 将数据写入 w 中，直到没有数据可写或发生错误。其返回值 n 为写入的字节数。 在写入过程中遇到的任何错误也将被返回。

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

    这两个接口比较适合于一次性传输数据

  • Seeker

    Seek 设置下一次 Read 或 Write 的偏移量为 offset，它的解释取决于 whence： 0 表示相对于文件的起始处，1 表示相对于当前的偏移，而 2 表示相对于其结尾处。 Seek 返回新的偏移量和一个错误，如果有的话。

    这个whence就很灵活，可以让你从开头 现在 结尾开始设置偏移量

    1
    2
    3
    type Seeker interface {
        Seek(offset int64, whence int) (ret int64, err error)
    }

    whence 的值，在 io 包中定义了相应的常量，应该使用这些常量

    1
    2
    3
    4
    5
    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
    )

  • Closer

    1
    2
    3
    type Closer interface{
    	Close() error 
    }

    用于关闭数据流

  • other….

    1
    func Copy(dst Writer, src Reader) (written int64, err error)
    1
    func ReadFull(r Reader, buf []byte) (n int, err error)
    1
    func WriteString(w Writer, s string) (n int, err error)
    1
    2
    3
    4
    type ByteScanner interface {
        ByteReader
        UnreadByte() error
    }

…..

随便看看……….