IO操作是咱编程时经常会遇到的，两种语言都提供了通用的Read方法，可以让咱从reader结构体里面读出数据。

Go

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

//bytes/reader.go
type Reader struct {
    s        []byte
    i        int64 // current reading index
    prevRune int   // index of previous rune; or < 0
}

// Read implements the io.Reader interface.
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
}

可以看出在 go 语言里面某个类型是否实现了某个接口，是没有显示标注的，只要函数签名相同，就可以说是实现了这个接口。

a.Read(b)表示把a里面的数据复制到b，并修改a里的已读坐标。

举个栗子

import (
    "bytes"
)

func main() {
    reader := bytes.NewReader([]byte{1, 2, 3})
    target := make([]byte, 5)
    fmt.Println(reader, target)
    reader.Read(target)
    fmt.Println(reader, target)
}

&{[1 2 3] 0 -1} [0 0 0 0 0]
&{[1 2 3] 3 -1} [1 2 3 0 0]

Rust

pub trait Read {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
    
impl Read for &[u8] {
    #[inline]
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        let amt = cmp::min(buf.len(), self.len());
        let (a, b) = self.split_at(amt);

        // First check if the amount of bytes we want to read is small:
        // `copy_from_slice` will generally expand to a call to `memcpy`, and
        // for a single byte the overhead is significant.
        if amt == 1 {
            buf[0] = a[0];
        } else {
            buf[..amt].copy_from_slice(a);
        }

        *self = b;
        Ok(amt)
    }

与 Go 语言里的复制不同，这里被read的时候，原始数据会被修改，只留下还未read的部分。

又举个栗子

use std::io::Read;

fn main() {
    let mut reader: &[u8] = &[1, 2, 3][..];
    let target: &mut [u8] = &mut [0;5][..];
    reader.read(target);
    
    let empty_slice: &[u8] = &[][..];
    assert_eq!(reader, empty_slice);
    assert_eq!(target, &[1,2,3,0,0]);
}

有疑问加站长微信联系（非本文作者）