GoLang strings.Builder底层实现方法详解

10-12 121阅读 0评论

?=1.strings.Builder结构体

1.1strings.BUIlder结构

// A Builder is used to eFFIciently build a string using Write methods. // It minimizes memory Copying. The zero value is ready to use. // Do not copy a non-zero Builder. type Builder Struct { 	addr *Builder // of receiver, to detect copies by value 	buf  []byte } 

1.2Write方法

// Write appends the contenTS of p to b's buffer. // Write always returns len(p), nil. func (b *Builder) Write(p []byte) (int, error) { 	b.copyCheck() 	b.buf = append(b.buf, p...) 	return len(p), nil } 

1.3WriteByte方法

// WriteByte appends the byte c to b's buffer. // The returned error is always nil. func (b *Builder) WriteByte(c byte) error { 	b.copyCheck() 	b.buf = append(b.buf, c) 	return nil } 

1.4WriteRune方法

// WriteRune appends the UTF-8 encoDIng of Unicode code point r to b's buffer. // It returns the length of r and a nil error. func (b *Builder) WriteRune(r rune) (int, error) { 	b.copyCheck() 	// Compare as uint32 to correctly handle negative runes. 	if uint32(r) < utf8.Runeself { 		b.buf = append(b.buf, byte(r)) 		return 1, nil 	} 	l := len(b.buf) 	if cap(b.buf)-l < utf8.UTFMax { 		b.grow(utf8.UTFMax) 	} 	n := utf8.EncodeRune(b.buf[l:l+utf8.UTFMax], r) 	b.buf = b.buf[:l+n] 	return n, nil } 

1.5.Writestring方法

// WriteString appends the contents of s to b's buffer. // It returns the length of s and a nil error. func (b *Builder) WriteString(s string) (int, error) { 	b.copyCheck() 	b.buf = append(b.buf, s...) 	return len(s), nil } 

1.6String方法

和 bytes.Buffer一样,strings.Builder 也支持使用 String() 来获取最终的字符串结果。为了节省内存分配,它通过使用指针技术将内部的 buffer bytes 转换字符串。所以 String() 方法在转换的时候节省了时间和空间。

// String returns the accumulated string. func (b *Builder) String() string { 	return *(*string)(unsafe.Pointer(&b.buf)) } 

1.7Len方法

// Len returns the number of accumulated bytes; b.Len() == len(b.String()). func (b *Builder) Len() int { return len(b.buf) } 

1.8Cap方法

// Cap returns the capacity of the builder's underlying byte slice. It is the // total space allocated for the string being built and includes any bytes // already written. func (b *Builder) Cap() int { return cap(b.buf) } 

1.9Reset方法

// Reset resets the Builder to be empty. func (b *Builder) Reset() { 	b.addr = nil 	b.buf = nil } 

1.10Grow方法

// Grow grows b's capacity, if necessary, to guarantee space for // another n bytes. After Grow(n), at least n bytes can be written to b // without another allocatiON. If n is negative, Grow panics. func (b *Builder) Grow(n int) { 	b.copyCheck() 	if n < 0 { 		panic("strings.Builder.Grow: negative count") 	} 	if cap(b.buf)-len(b.buf) < n { 		b.grow(n) 	} } 

1.11grow方法

// grow copies the buffer to a new, larger buffer so that there are at least n // bytes of capacity beyond len(b.buf). func (b *Builder) grow(n int) { 	buf := make([]byte, len(b.buf), 2*cap(b.buf)+n) 	copy(buf, b.buf) 	b.buf = buf } 

1.12copyCheck方法

func (b *Builder) copyCheck() { 	if b.addr == nil { 		// this hack works around a failing of Go's escape analysis 		// that was causing b to escape and be heap allocated. 		// See issue 23382. 		// TODO: once issue 7921 is fixed, this should be reverted to 		// just "b.addr = b". 		b.addr = (*Builder)(noescape(unsafe.Pointer(b))) 	} else if b.addr != b { 		panic("strings: illegal use of non-zero Builder copied by value") 	} } 

2.strings.Builder介绍

与 bytes.Buffer 似,strings.Builder 也支持 4 类方法将数据写入 builder 中。

func (b *Builder) Write(p []byte) (int, error)

func (b *Builder) WriteByte(c byte) error

func (b *Builder) WriteRune(r rune) (int, error)

func (b *Builder) WriteString(s string) (int, error)

有了它们,用户可以根据输入数据的不同类型(byte 数组,byte, rune 或者 string),选择对应的写入方法。

3.存储原理

根据用法说明,我们通过调用 string.Builder 的写入方法来写入内容,然后通过调用 String() 方法来获取拼接的字符串。那么 string.Builder 是如何组织这些内容的呢?

通过 slice,string.Builder 通过使用一个内部的 slice 来存储数据片段。当开发者调用写入方法的时候,数据实际上是被追加(append)到了其内部的 slice 上。

4.拷贝问题

strings.Builder 不推荐被拷贝。当你试图拷贝 strings.Builder 并写入的时候,你的程序就会崩溃。

你已经知道,strings.Builder 内部通过 slice 来保存和管理内容。slice 内部则是通过一个指针指向实际保存内容的数组。 当我们拷贝了 builder 以后,同样也拷贝了其 slice 的指针。但是它仍然指向同一个旧的数组。当你对源 builder 或者拷贝后的 builder 写入的时候,问题就产生了。另一个 builder 指向的数组内容也被改变了。这就是为什么 strings.Builder 不允许拷贝的原因。

func main() { 	var b1 strings.Builder 	b1.WriteString("ABC") 	b2 := b1 	b2.WriteString("DEF")//出错在这一行,panic: strings: illegal use of non-zero Builder copied by value } 
func main() { 	var b1 strings.Builder 	b1.WriteString("ABC") 	b2 := b1 	fmt.Println(b2.String())//ABC } 
func main() { 	var b1 strings.Builder 	b1.WriteString("ABC") 	b2 := b1 	fmt.Println(b1.String()) //输出:ABC 	fmt.Println(b2.String()) //输出:ABC 	b1.WriteString("DEF") 	fmt.Println(b1.String()) //输出:ABCDEF 	fmt.Println(b2.String()) //输出:ABC } 

但对于一个未写入任何东西的空内容 builder 则是个例外。我们可以拷贝空内容的 builder 而不报错

func main() { 	var b1 strings.Builder 	b2 := b1 	fmt.Println(b1.String()) //输出空行 	fmt.Println(b2.String()) //输出空行 	b2.WriteString("DEF") 	fmt.Println(b1.String()) //输出空行 	fmt.Println(b2.String()) //输出:DEF 	b1.WriteString("ABC") 	fmt.Println(b1.String()) //输出:ABC 	fmt.Println(b2.String()) //输出:DEF } 

strings.Builder 会在以下方法中检测拷贝操作

Grow(n int)

Write(p []byte)

WriteRune(r rune)

WriteString(s string)

所以,拷贝并使用下列这些方法是允许的:

func main() { 	// Reset() 	// Len() 	// String() 	var b1 strings.Builder 	b1.WriteString("ABC") 	b2 := b1 	fmt.Println(b2.Len())// 3 	fmt.Println(b2.String()) // ABC 	b2.Reset() 	b2.WriteString("DEF") 	fmt.Println(b2.String()) // DEF } 

5.不能与nil作比较

GoLang strings.Builder底层实现方法详解

6.Grow深入

strings.Builder 是通过其内部的 slice 来储存内容的。当你调用写入方法的时候,新的字节数据就被追加到 slice 上。如果达到了 slice 的容量(capacity)限制,一个新的 slice 就会被分配,然后老的 slice 上的内容会被拷贝到新的 slice 上。当 slice 长度很大时,这个操作就会很消耗资源甚至引起 内存问题。我们需要避免这一情况。

关于 slice,GO 语言提供了 make([]TypeOfSlice, length, capacity) 方法在初始化的时候预定义它的容量。这就避免了因达到最大容量而引起扩容。

strings.Builder 同样也提供了 Grow() 来支持预定义容量。当我们可以预定义我们需要使用的容量时,strings.Builder 就能避免扩容而创建新的 slice 了。

当调用 Grow() 时,我们必须定义要扩容的字节数(n)。 Grow() 方法保证了其内部的 slice 一定能够写入 n 个字节。只有当 slice 空余空间不足以写入 n 个字节时,扩容才有可能发生。

举个例子:

builder 内部 slice 容量为 10。

builder 内部 slice 长度为 5。

当我们调用 Grow(3) => 扩容操作并不会发生。因为当前的空余空间为 5,足以提供 3 个字节的写入。

当我们调用 Grow(7) => 扩容操作发生。因为当前的空余空间为 5,已不足以提供 7 个字节的写入。

关于上面的情形,如果这时我们调用 Grow(7),则扩容之后的实际容量是多少?

17 还是 12?

实际上,是 27。strings.Builder 的 Grow() 方法是通过 current_capacity * 2 + n (n 就是你想要扩充的容量)的方式来对内部的 slice 进行扩容的。所以说最后的容量是 10*2+7 = 27。 当你预定义 strings.Builder 容量的时候还要注意一点。调用 WriteRune() 和 WriteString() 时,rune 和 string 的字符可能不止 1 个字节。因为,你懂的,UTF-8 的原因。

func main() { 	var b1 strings.Builder 	fmt.Println(b1.Len()) //0 	fmt.Println(b1.Cap()) //0 	b1.Grow(3) 	fmt.Println(b1.Len()) //0 	fmt.Println(b1.Cap()) //3 	b1.Grow(1) 	fmt.Println(b1.Len()) //0 	fmt.Println(b1.Cap()) //3 } 
func main() { 	a := strings.Builder{} 	a.Grow(11) 	fmt.Println(a.Len()) //0 	fmt.Println(a.Cap()) //11 	a.WriteRune('李') 	a.WriteRune('陆') 	a.WriteRune('豪') 	a.WriteRune('Z') 	a.WriteRune('Z') 	fmt.Println(a.Len()) //11 	fmt.Println(a.Cap()) //11	 } 

7.不支持并行读写

和 bytes.Buffer 一样,strings.Builder 也不支持并行的读或者写。所以我们们要稍加注意。

可以试一下,通过同时给 strings.Builder 添加 1000 个字符:

通过运行,你会得到不同长度的结果。但它们都不到 1000。

func main() { 	var b strings.Builder 	n := 0 	var wait sync.WaitGroup 	for n < 1000 { 		wait.Add(1) 		go func() { 			b.WriteString("1") 			n++ 			wait.Done() 		}() 	} 	wait.Wait() 	fmt.Println(len(b.String())) 	/* 			第一次运行输出:946 		   第二次运行输出:933 		 第三次运行输出:900 	*/ } 

到此这篇关于golang strings.Builder底层实现方法详解的文章就介绍到这了,更多相关Golang strings.Builder内容请搜索云初冀北以前的文章或继续浏览下面的相关文章希望大家以后多多支持云初冀北!

免责声明
本站提供的资源,都来自网络,版权争议与本站无关,所有内容及软件的文章仅限用于学习和研究目的。不得将上述内容用于商业或者非法用途,否则,一切后果请用户自负,我们不保证内容的长久可用性,通过使用本站内容随之而来的风险与本站无关,您必须在下载后的24个小时之内,从您的电脑/手机中彻底删除上述内容。如果您喜欢该程序,请支持正版软件,购买注册,得到更好的正版服务。侵删请致信E-mail:goliszhou@gmail.com
$

发表评论

表情:
评论列表 (暂无评论,121人围观)

还没有评论,来说两句吧...