Golong字符串拼接性能優(yōu)化方法及原理是什么

這篇文章主要介紹了Golong字符串拼接性能優(yōu)化方法及原理是什么的相關(guān)知識，內(nèi)容詳細(xì)易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇Golong字符串拼接性能優(yōu)化方法及原理是什么文章都會有所收獲，下面我們一起來看看吧。

1.字符串高效拼接

go 字符串是不可修改的，所謂字符串拼接就是創(chuàng)建新的字符串對象。如果代碼中存在大量的字符串拼接，那么性能將會存在影響。

1.1 常見的字符串拼接

+號

func plusConcat(n int, s string) string {
	var d string
	for i := 0; i < n; i++ {
		d += s
	}
	return d
}

格式化

func sprintfConcat(n int, s string) string {
	var d string
	for i := 0; i < n; i++ {
		d = fmt.Sprintf("%s%s", d, s)
	}
	return d
}

strings.Builder

func builderConcat(n int, s string) string {
	var sb = new(strings.Builder)
	for i := 0; i < n; i++ {
		sb.WriteString(s)
	}
	return sb.String()
}

bytes.Buffer

func bufferConcat(n int, s string) string {
	var bb = new(bytes.Buffer)
	for i := 0; i < n; i++ {
		bb.WriteString(s)
	}
	return bb.String()
}

[]byte

func byteConcat(n int, s string) string {
	var b = make([]byte, 0)
	for i := 0; i < n; i++ {
		b = append(b, s...)
	}
	return string(b)
}

預(yù)分配[]byte

func preByteConcat(n int, s string) string {
	var b = make([]byte, 0, n*len(s))
	for i := 0; i < n; i++ {
		b = append(b, s...)
	}
	return string(b)
}

1.2 字符串拼接測試

定義一個隨機(jī)字符串生成函數(shù)：

const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
func randomString(n int) string {
	b := make([]byte, n)
	for i := range b {
		b[i] = letterBytes[rand.Intn(len(letterBytes))]
	}
	return string(b)
}

對上述6中字符串拼接函數(shù)進(jìn)行基準(zhǔn)測試：

func benchmark(b *testing.B, f func(int, string) string) {
	var str = randomString(10)
	for i := 0; i < b.N; i++ {
		f(10000, str)
	}
}
func BenchmarkPlusConcat(b *testing.B)    { benchmark(b, plusConcat) }
func BenchmarkSprintfConcat(b *testing.B) { benchmark(b, sprintfConcat) }
func BenchmarkBuilderConcat(b *testing.B) { benchmark(b, builderConcat) }
func BenchmarkBufferConcat(b *testing.B)  { benchmark(b, bufferConcat) }
func BenchmarkByteConcat(b *testing.B)    { benchmark(b, byteConcat) }
func BenchmarkPreByteConcat(b *testing.B) { benchmark(b, preByteConcat) }

go test -bench=. test/string -benchmem

毫無疑問 + 和 格式化 兩種方式最耗時，且內(nèi)存分配還多。

性能最好的是預(yù)分配[]byte方式，它只進(jìn)行兩次內(nèi)存分配，其余部分全部在進(jìn)行內(nèi)存拷貝操作。

其次是strings.builder

然后是bytes.buffer

緊接著是 []byte方式

1.3 推薦

一般來說，選擇使用string.Builder方式來進(jìn)行拼接。

其次，strings.Builder 提供了 Grow方法，特殊情況下避免多次內(nèi)存分配。

func builderConcat(n int, s string) string {
	var sb = new(strings.Builder)
	sb.Grow(n * len(s))
	for i := 0; i < n; i++ {
		sb.WriteString(s)
	}
	return sb.String()
}

然后Builder 再與 預(yù)分配的[]byte 比較：

得出：builder 比 預(yù)分配[]byte 少一次內(nèi)存分配，當(dāng)然內(nèi)存使用也會少一半。

2.相關(guān)原理

2.1 + 號

+ 性能如此差是因?yàn)間o 字符串本省不可修改，兩個字符串拼接，那么新構(gòu)造一個字符串，長度等與兩個字符串長度之和，然后分別將兩個字符串的內(nèi)容拷貝到新的字符串中。且如果連續(xù)的字符串拼接，就像plusConcat函數(shù),會產(chǎn)生大量臨時對象d,對GC也是一種壓力。

2.2 strings.Builder 與 bytes.Buffer

2.2.1 內(nèi)部[]byte 增長方式：

strings.Builder 內(nèi)部采用[]byte存儲,初始大小為0，每次寫入是按go 默認(rèn)切片增長方式拓展底層[]byte的長度。

bytes.Buffer 內(nèi)存采用[]byte,其內(nèi)部有控制增長的算法，最小申請空間就為64bytes,在寫入為超過一倍的情況下，是按1一倍空間增加。

64 128 256 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 ...

2.2.2 性能比較

為啥 Buffer 比 Builder 多一次內(nèi)存分配：

Buffer 的String() 方法：

func (b *Buffer) String() string {
	if b == nil {
		// Special case, useful in debugging.
		return "<nil>"
	}
	return string(b.buf[b.off:])
}

Builder 的String() 方法：

// String returns the accumulated string.
func (b *Builder) String() string {
	return unsafe.String(unsafe.SliceData(b.buf), len(b.buf))
}

可以看出，Buffer在轉(zhuǎn)字符串時，需要重新構(gòu)造string對象；而Builder 返回的string 對象則直接復(fù)用Builder 底層的buf。

關(guān)于“Golong字符串拼接性能優(yōu)化方法及原理是什么”這篇文章的內(nèi)容就介紹到這里，感謝各位的閱讀！相信大家對“Golong字符串拼接性能優(yōu)化方法及原理是什么”知識都有一定的了解，大家如果還想學(xué)習(xí)更多知識，歡迎關(guān)注億速云行業(yè)資訊頻道。