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]);
}

本文来自:Segmentfault

感谢作者:Tericoder

查看原文:通过例子学习 Go 和 Rust ---- IO Reader

• 编辑
• 预览