Golong字符串拼接性能優化方法及原理是什么

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

1.字符串高效拼接

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

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

預分配[]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 字符串拼接測試

定義一個隨機字符串生成函數：

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中字符串拼接函數進行基準測試：

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

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

性能最好的是預分配[]byte方式，它只進行兩次內存分配，其余部分全部在進行內存拷貝操作。

其次是strings.builder

然后是bytes.buffer

緊接著是 []byte方式

1.3 推薦

一般來說，選擇使用string.Builder方式來進行拼接。

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

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 再與 預分配的[]byte 比較：

得出：builder 比 預分配[]byte 少一次內存分配，當然內存使用也會少一半。

2.相關原理

2.1 + 號

+ 性能如此差是因為go 字符串本省不可修改，兩個字符串拼接，那么新構造一個字符串，長度等與兩個字符串長度之和，然后分別將兩個字符串的內容拷貝到新的字符串中。且如果連續的字符串拼接，就像plusConcat函數,會產生大量臨時對象d,對GC也是一種壓力。

2.2 strings.Builder 與 bytes.Buffer

2.2.1 內部[]byte 增長方式：

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

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

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

2.2.2 性能比較

為啥 Buffer 比 Builder 多一次內存分配：

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在轉字符串時，需要重新構造string對象；而Builder 返回的string 對象則直接復用Builder 底層的buf。

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