前言

前面三篇文章 Go语言 io包核心接口详解Go语言 io包基本接口详解Go语言 io包源码解读,我们学习了Go语言 io 包中的接口和方法,本篇文章我们就来学习下具体的实现-strings.Reader。strings.Reader 用于高效的读取字符串,实现了 io.Reader、io.ReaderAt、io.Seeker、io.WriterTo、io.ByteScanner、io.RuneScanner 接口,下面我们就通过阅读源码来学习下底层实现吧!

定义

  • s: 初始化传入的字符串,后续的操作都是对该字符串的操作
  • i: 已读计数,保存下次读取的开始位置,默认是0(第一次读取就是从0开始),读取n个byte后,会相应的加n。
  • prevRune: 保存上一个Rune的位置,默认是-1,只有在调用 ReadRune 方法的时候才会增加
1
2
3
4
5
type Reader struct {
	s        string
	i        int64 
	prevRune int   
}

方法定义

NewReader

初始化一个 Strings.Reader,传入需要操作的字符串,初始化当前读取位置 i=0,prevRune=-1

1
func NewReader(s string) *Reader { return &Reader{s, 0, -1} }

Len

Len 方法返回 未读取 部分的长度

1
2
3
4
5
6
7
8
func (r *Reader) Len() int {
	// 如果当前读取开始位置 i 大于等于 字符串 的长度,说明之前已经读取完了字符串,此时返回0
	if r.i >= int64(len(r.s)) {
		return 0
	}
	// 返回剩余长度
	return int(int64(len(r.s)) - r.i)
}

Size

Size 方法返回原始字符串的长度,每次调用该方法的返回值都相同,不受其他方法的影响;利用 Size()-Len(),可以计算出已经读取的字节数

1
func (r *Reader) Size() int64 { return int64(len(r.s)) }

Read

Read 方法读取字符串到字节切片 b 中,返回读取的字节长度和产生的 error

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// Read 方法读取字符串到字节切片 b 中,返回读取的字节长度和产生的 error
func (r *Reader) Read(b []byte) (n int, err error) {

	// 如果当前读取开始位置,已经大于等于字符串长度,说明已经对字符串读取完毕了,返回 EOF error
	if r.i >= int64(len(r.s)) {
		return 0, io.EOF
	}

	// 只有在调用 ReadRune 方法的时候才会修改,如果调用其他方法都会设置为默认值
	r.prevRune = -1

	// 调用 copy 方法,从当前位置 i 开始,将字符串 s 中的数据拷贝至字节切片 b 中,返回拷贝的字节数 n
	n = copy(b, r.s[r.i:])

	// 当前读取的位置往后移动 n 个
	r.i += int64(n)
	return
}

ReadAt

  • ReadAt 从指定位置 off 开始读取字符串至字节切片 b 中,返回读取到的字节数 n 以及产生的 error
  • ReadAt 不会修改已读计数 i,也不会修改 prevRune 值
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) {
	// 如果传入的 off < 0,是非法偏移量
	if off < 0 {
		return 0, errors.New("strings.Reader.ReadAt: negative offset")
	}

	// 如果传入的 off 大于等于 字符串的长度,那么就没有数据可以读取了,返回 EOF error
	if off >= int64(len(r.s)) {
		return 0, io.EOF
	}

	// 其他位置就是合法位置
	// 从 off 位置开始,调用 copy 方法,复制数据到字节切片 b 中,返回复制的字节数
	n = copy(b, r.s[off:])

	// 根据 ReaderAt 接口的定义,如果读取的字节长度小于传入字节切片的长度,返回的 err 不能为 nil,需要说明原因
	// 如果复制的字节数小于字节切片 b 的长度,说明已经复制到了字符串结尾,不够填充满字节切片b 了,返回 EOF error
	if n < len(b) {
		err = io.EOF
	}
	return
}

ReadByte

读取一个字节,返回读取的字节和产生的error

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
func (r *Reader) ReadByte() (byte, error) 
	// 只有在调用 ReadRune 方法的时候才会修改,如果调用其他方法都会设置为默认值
	r.prevRune = -1

	// 如果当前读取开始位置,大于等于字符串长度,说明已经读取完毕了,返回 EOF error
	if r.i >= int64(len(r.s)) {
		return 0, io.EOF
	}
	// 读取当前开始位置的字节,然后将 i+1
	b := r.s[r.i]
	r.i++
	return b, nil
}

UnreadByte

回退一个字节,将已读计数的值减一

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
func (r *Reader) UnreadByte() error {
	// 如果当前开始位置 i <= 0,再减一非法了,返回 error
	if r.i <= 0 {
		return errors.New("strings.Reader.UnreadByte: at beginning of string")
	}

	// 只有在调用 ReadRune 方法的时候才会修改,如果调用其他方法都会设置为默认值
	r.prevRune = -1

	// 回退一个字节
	r.i--
	return nil
}

ReadRune

  • ReadRune 作用是读取一个 UTF-8 字符,返回读取的 rune、字节数 以及 产生的 error
  • rune 不同于字节,而是一个 UTF-8 字符,比如中文 “我” 是三个字节,英文字母 ‘a’ 是一个字节,而两者都可以表示为一个rune(UTF-8 字符)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func (r *Reader) ReadRune() (ch rune, size int, err error) {
	// 如果当前开始位置 i 已经大于等于字符串长度,已经没有数据可以读取,返回 EOF error
	if r.i >= int64(len(r.s)) {
		r.prevRune = -1
		return 0, 0, io.EOF
	}

	// 如果当前位置合法,设置prevRune为当前 i 的位置,然后进行读取。
	r.prevRune = int(r.i)

	// 判断当前 i 位置的字节值是否小于utf8.RuneSelf
  // 小于表示当前的字节就是一个独立的UTF-8 字符,那么返回这个字节对应的数据即可
	if c := r.s[r.i]; c < utf8.RuneSelf {
		// 本次只读取了一个字节,i+1
		r.i++
		return rune(c), 1, nil
	}

	// DecodeRuneInString 从字符串指定位置开始,返回从该位置开始的一个完整的 rune,以及对应的字节数
	// 从当前 i 位置开始,调用 DecodeRuneInString 方法,并更新 i 值
	ch, size = utf8.DecodeRuneInString(r.s[r.i:])
	r.i += int64(size)
	return
}

UnreadRune

  • UnreadRune表示回退一个 rune,,而且只能回退一次
  • 这个方法只有在运行过 ReadRune 后,且没有运行 Read、ReadByte、UnreadByte、Seek、WriteTo方法时调用才有效(这些方法会将 prevRune 更新为默认值)
  • 需要注意的是,ReadRune调用后,运行 ReadAt 方法不改变 prevRune 的状态,可以使用 UnreadRune 回退
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
func (r *Reader) UnreadRune() error {
	// 未操作过字符串,不能回退
	if r.i <= 0 {
		return errors.New("strings.Reader.UnreadRune: at beginning of string")
	}
	// 非法位置,无法回退
	if r.prevRune < 0 {
		return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune")
	}
	// 修改已读计数 i 为 prevRune
	r.i = int64(r.prevRune)

	// prevRune 设置为默认值,不能再次回退了
	r.prevRune = -1
	return nil
}

Seek

Seek 基于 起始位置 whence 和 偏移量 offset,返回新的位置和产生的 error,同时也会修改已读计数 i,设定下一次读取的起始位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func (r *Reader) Seek(offset int64, whence int) (int64, error) {
	r.prevRune = -1
	var abs int64
	switch whence {
		// 从开始位置开始,也就是从0开始,那么就设置为入参 offset
	case io.SeekStart:
		abs = offset
		//从当前位置开始,也就是从 i 开始,设置为 i + offset
	case io.SeekCurrent:
		abs = r.i + offset
		// 从末尾开始,也就是从字符串默认位置开始
	case io.SeekEnd:
		abs = int64(len(r.s)) + offset
	default:
		// 其他 whence 入参非法
		return 0, errors.New("strings.Reader.Seek: invalid whence")
	}
	// 根据Seeker接口的定义,如果新的 offset 在文件开始位置之前,是非法的,需要返回 err!=nil
	if abs < 0 {
		return 0, errors.New("strings.Reader.Seek: negative position")
	}
	// 更新位置
	r.i = abs
	return abs, nil
}

WriteTo

WriteTo方法,将从已读计数 i 开始的数据,交给 Writer w 写入,返回写入的字节数和产生的error

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
	// 将 prevRune 设置为默认值
	r.prevRune = -1

	// 如果当前开始位置 i 大于等于 字符串长度,没有数据可写
	if r.i >= int64(len(r.s)) {
		return 0, nil
	}
	// 从 i 位置开始的数据,调用 io.WriteString 方法,交给 Writer w 写入,返回写入的字节数和err
	s := r.s[r.i:]
	m, err := io.WriteString(w, s)

	// 如果写入的字节数,比入参字符串长度还长,不合理,直接panic
	if m > len(s) {
		panic("strings.Reader.WriteTo: invalid WriteString count")
	}

	// 被读取了 m 个字节,更新 i 位置
	r.i += int64(m)

	/* 
	如果写入的字符,比传递字符串的长度不相等,且 err==nil,返回 ErrShortWrite
	
	分析:
	
	上面调用的 WriteString(w Writer, s string)方法,该方法定义如下:
	
	func WriteString(w Writer, s string) (n int, err error) {
		if sw, ok := w.(StringWriter); ok {
			return sw.WriteString(s)
		}
		return w.Write([]byte(s))
	}
	
	1.根据 WriteString(w Writer, s string)的逻辑,如果传入的 Writer w 实现了StringWriter接口,
	进一步会直接调用StringWriter.WriteString方法,该方法没有约束返回的写入字节数、产生的error 与入参字符串之间的规范

	2. 如果传入的 Writer w 没有实现StringWriter接口,会直接调用Writer.Write 方法
	Write 方法明确说明:如果写入的字节数小于传入的字节数,err 一定不为 nil

	因此这里的 m != len(s) && err == nil , 一定是第一种情形返回的
	*/
	n = int64(m)
	if m != len(s) && err == nil {
		err = io.ErrShortWrite
	}
	return
}

Reset

重置:将整个结构初始化为最初状态,设置新的字符串

1
func (r *Reader) Reset(s string) { *r = Reader{s, 0, -1} }

测试使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
func main() {
	reader := strings.NewReader("this is a test")
	fmt.Println(reader.Size()) // 字符串长度  14
	fmt.Println(reader.Len())  // 未读字节数  14

	b := make([]byte, 10)
	n, err := reader.Read(b)           // 读取10个字节
	fmt.Println(n, err)                // 10 <nil>
	fmt.Println("'" + string(b) + "'") // 'this is a '

	// 当前 i=10
	t, err := reader.ReadByte()
	fmt.Println(string(t), err) // t <nil>
	_ = reader.UnreadByte()     // 回退一个字节
	t, err = reader.ReadByte()
	fmt.Println(string(t), err) // t <nil>

	offset, err := reader.Seek(5, io.SeekStart) // 设置 i=5
	b = make([]byte, 10)
	n, err = reader.ReadAt(b, offset)  // 14-5,读取9个字节
	fmt.Println(n, err)                // 9 EOF
	fmt.Println("'" + string(b) + "'") // 'is a test'

	r, s, err := reader.ReadRune() // 从 i=5,读取一个 rune
	fmt.Println(string(r), s, err) // i 1 <nil>

	reader.Reset("这是一个测试") // reset i=0
	r, s, err = reader.ReadRune()
	fmt.Println(string(r), s, err) // 这 3 <nil>
	_ = reader.UnreadRune()        // 回退一个rune
	r, s, err = reader.ReadRune()
	fmt.Println(string(r), s, err) //这 3 <nil>
}

总结

本篇文章学习了strings.Reader,对涉及到的所有方法进行了源码级别的分析,并给出了使用示例。在strings.Reader中,比较重要的变量就是已读计数 i 了,下面总结了几条该字段何时会被更新:

  • Reader 拥有的大部分用于读取的方法都会及时地更新已读计数
  • ReadByte 方法会在读取成功后将这个计数的值加 1,ReadRune方法在读取成功之后,会把被读取的字符所占用的字节数作为计数的增量
  • ReadAt方法算是一个例外,它既不会依据已读计数进行读取,也不会在读取后更新它。正因为如此,这个方法可以自由地读取其所属的Reader值中的任何内容
  • Reader值的 Seek 方法也会更新该值的已读计数,实际上,这个Seek方法的主要作用正是设定下一次读取的起始索引位置

更多

微信公众号:CodePlayer