go字符串拼接方式及性能比拼小結
在golang中字符串的拼接方式有多種，本文將會介紹比較常用的幾種方式，并且對各種方式進行壓測，以此來得到在不同場景下更適合使用的方案。
1、go字符串的幾種拼接方式
比如對于三個字符串，s1、s2、s3，需要將其拼接為一個字符串，有如下的幾種方式：
1.1 fmt.Sprintf
s := fmt.Sprintf("%s%s%s", s1, s2, s3)
1.2 +運算符拼接
s := s1 + s2 + s3
1.3 strings.Join
s := strings.Join([]string{s1, s2, s3}, "")
1.4 strings.Builder
builder := strings.Builder{}
builder.WriteString(s1)
builder.WriteString(s2)
builder.WriteString(s3)
s := builder.String()
1.5 bytes.Buffer
buffer := bytes.Buffer{}
buffer.WriteString(s1)
buffer.WriteString(s2)
buffer.WriteString(s3)
s := buffer.String()
2、性能測試
上面介紹了5種字符串的拼接方式，那么它們的性能如何呢，接下來將對這五種字符串拼接進行一個性能測試：
go版本：go1.21.0
如下為性能測試的結果，代碼將在最后面給出，總共有八種，分別為：
1.fmt.Sprintf
2.+
3.使用for循環(huán)和+拼接
4.strings.join
5.strings.Builder
6.strings.Builder(先使用Grow擴容)
7.bytes.Buffer
8.bytes.Buffer(先使用Grow擴容)
性能測試的結果如下(僅供參考)：
拼接的字符串數量：3， 字符串長度：10， 性能如下
當字符串數量和長度較小時，性能從高到低：
+拼接 > strings.Builder(先Grow) > strings.Join > bytes.Buffer > bytes.Buffer(先Grow) > strings.Builder > +拼接（使用for循環(huán)） > fmt.Sprintf
拼接的字符串數量：5， 字符串長度：128， 性能如下
當字符串數量較多和長度較大時，性能從高到低：
strings.Builder(先Grow) > +拼接 > strings.Join > bytes.Buffer(先Grow) > fmt.Sprintf > strings.Builder > +拼接(使用for循環(huán)) > bytes.Buffer
從上面的壓測來看，直接使用+拼接字符串和使用strings.Builder(需要先grow)以及使用strings.Join的性能都是不錯的。上面有幾個重點需要關注的點：
1. 當字符串數量較少長度較小時，使用+來拼接字符串的效率非常高并且內存分配次數為0（棧內存分配）
2. 當字符串數量較少長度較小時，bytes.Grow使用和不使用區(qū)別不大 （bytes.Buffer的最小擴容容量為64）
3. fmt.Sprintf的內存分配次數最多（涉及大量的interface{}操作，導致逃逸）
接下來將從源碼的角度來分析它們的性能
3、源碼分析
注意：go的版本為1.21.0
3.1 +拼接
如果從感覺上來講，我們通常會認為使用+來拼接字符串肯定是最低效的，因為會有多次字符串的拷貝，結果不然，接下來從源碼的角度進行分析，看為什么使用+來拼接字符串的效率是非常高的：
源碼位于runtime/string.go下：
concatstrings實現了go的字符串+拼接，所有的字符串會被放入一個字符串切片中，并且會傳入一個大小為32字節(jié)的字符數組。
如果拼接后的字符串長度較小并且不會發(fā)生逃逸，那么就會在棧上創(chuàng)建出大小為32字節(jié)的字符數組。
步驟如下：
- 首先計算拼接后的字符串的長度；
- 如果編譯器可以確定拼接后的字符串不會發(fā)生逃逸，buf就不為nil，如果buf不為nil并且buf可以存放下拼接后的字符串，就使用buf
- 如果buf為nil或者大小不足，則會在堆上申請出一片可以存放下拼接后的字符串的空間，然后將字符串一個一個拷貝過去
// The constant is known to the compiler.
// There is no fundamental theory behind this number.
const tmpStringBufSize = 32
type tmpBuf [tmpStringBufSize]byte
// concatstrings implements a Go string concatenation x+y+z+...
func concatstrings(buf *tmpBuf, a []string) string {
// 首先計算出拼接后的字符串的長度
idx := 0
l := 0
count := 0
for i, x := range a {
n := len(x)
if n == 0 {
continue
}
if l+n < l {
throw("string concatenation too long")
}
l += n
count++
idx = i
}
if count == 0 {
return ""
}
// 如果只有一個字符串并且它不在棧上或者我們的結果沒有轉義調用幀(但是f != nil)，那么我們可以直接返回該字符串。
if count == 1 && (buf != nil || !stringDataOnStack(a[idx])) {
return a[idx]
}
s, b := rawstringtmp(buf, l)
for _, x := range a {
copy(b, x)
b = b[len(x):]
}
return s
}
func rawstringtmp(buf *tmpBuf, l int) (s string, b []byte) {
// 如果buf不為nil而且buf可以存放下拼接后的字符串，就直接使用buf
if buf != nil && l <= len(buf) {
b = buf[:l]
s = slicebytetostringtmp(&b[0], len(b))
} else {
// 否則在堆上分配一片區(qū)域
s, b = rawstring(l)
}
return
}
// 在堆上分配一片內存，并且返回底層字符串結構和切片結構，它們指向同一片內存
func rawstring(size int) (s string, b []byte) {
p := mallocgc(uintptr(size), nil, false)
return unsafe.String((*byte)(p), size), unsafe.Slice((*byte)(p), size)
}
通過上面的源碼分析，可以得知，使用直接使用+拼接字符串會先申請出一片內存，然后將字符串一個一個拷貝過去，并且字符串有可能分配在棧上，因此效率非常高。
但是在使用for循環(huán)來拼接時，由于編譯器無法確定最終的內存空間大小，因此會發(fā)生多次拷貝，效率很低。
當字符串比較小并且數量是已知的時，使用+拼接字符串的效率很高，并且代碼可讀性更好。
3.2 strings.Builder
除了使用+來拼接字符串，通常string.Builder使用的也是非常多的，并且它的效率相比也是更高的，接下來看一下Builder的實現
在Builder中有一個字節(jié)切片的buf，每次在寫入時都會追加到buf中，當buf容量不足時，切片會自動擴容，但是在擴容時會拷貝舊的切片，因此如果預先使用Grow來分配內存，則可以減少擴容時的拷貝開銷，從而提高效率。
另一個高效的原因是在使用String()獲取字符串時直接共用了切片的底層存儲數組，從而減少了一次數據的拷貝。因此Builder的所有api都是只能追加，不能修改的。
type Builder struct {
addr *Builder // of receiver, to detect copies by value
buf []byte
}
func (b *Builder) WriteString(s string) (int, error) {
b.copyCheck()
b.buf = append(b.buf, s...)
return len(s), nil
}
func (b *Builder) grow(n int) {
buf := bytealg.MakeNoZero(2*cap(b.buf) + n)[:len(b.buf)]
copy(buf, b.buf)
b.buf = buf
}
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)
}
}
// 返回的string和buf共用了同一片底層字符數組，減少了數據拷貝
func (b *Builder) String() string {
return unsafe.String(unsafe.SliceData(b.buf), len(b.buf))
}
strings.Builder在獲取字符串時返回的string和buf共用同一片字符數組，因此減少了一次數據拷貝。在使用時，使用grow預先分配內存可以減少切片擴容時的數據拷貝，提高性能，因此建議先使用Grow進行預分配
3.3 strings.Join
在上面的性能測試中，Join的性能也很高，因為strings.join本身使用了strings.Builder，并且在拼接字符串之前使用Grow進行了內存預分配，因此效率也很高。
代碼很簡單，就不再介紹。
3.4 bytes.Buffer
bytes.Buffer和strings.Builder比較相似，但是通常用于處理字節(jié)數據，而不是字符串。一個區(qū)別就是在使用String()方法來獲取字符串時，有一次切片到字符串的拷貝，因此效率不如strings.Buffer但是當字符串長度較小時，bytes.Buffer的效率甚至比strings.Buffer要高。是因為，Builder的擴容是按照切片的擴容策略來的，而Buffer的初始最小擴容大小為64，也就是第一次擴容最小大小為64，因此使用Grow和不使用的區(qū)別不大。
func (b *Buffer) String() string {
if b == nil {
// Special case, useful in debugging.
return "<nil>"
}
return string(b.buf[b.off:])
}
const smallBufferSize = 64
func (b *Buffer) grow(n int) int {
...
if b.buf == nil && n <= smallBufferSize {
b.buf = make([]byte, n, smallBufferSize)
return 0
}
...
}
3.5 fmt.Sprintf
fmt.Sprintf的實現較為復雜，并且使用了大量的interface{}，會導致內存逃逸，涉及到多次內存分配，效率較低。如果是純字符串，通常不會使用fmt.Sprintf來進行拼接，fmt.Sprintf可以對多種數據格式進行字符串格式化。
總結：
1.當要拼接的多個字符串是已知并且數量較少時，可以直接使用+來拼接，效率比較高而且可讀性更好
2、當要拼接的字符串數量和長度未知時，可以使用strings.Builder來拼接，并且預估字符串的大小使用Grow進行預分配，效率較高
3、當要拼接的字符串數量已知或者在拼接時需要加入分割字符串時，可以使用strings.Join，效率較高，也很方便
4、在進行字節(jié)數據處理時可以使用bytes.Buffer
5、當要對包含多種格式的數據進行字符串格式化時使用fmt.Sprintf，更加方便
壓測代碼：
package string_concats
import (
"bytes"
"fmt"
"math/rand"
"strings"
"testing"
"time"
)
const dic = "qwertyuioplkjhgfdsazxcvbnmMNBVCXZASDFGHJKLPOIUYTREWQ0123456789"
var defaultRand = rand.New(rand.NewSource(time.Now().UnixNano()))
func RandString(n int) string {
builder := strings.Builder{}
builder.Grow(n)
for i := 0; i < n; i++ {
n := defaultRand.Intn(len(dic))
builder.WriteByte(dic[n])
}
return builder.String()
}
var (
strs []string
N = 5
Len = 128
)
func init() {
for i := 0; i < N; i++ {
strs = append(strs, RandString(Len))
}
}
// fmt.Sprintf
func BenchmarkSprintf(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = fmt.Sprintf("%s%s%s%s%s", strs[0], strs[1], strs[2], strs[3], strs[4])
}
}
// s1 + s2 + s3
func BenchmarkConcat(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = strs[0] + strs[1] + strs[2] + strs[3] + strs[4]
}
}
// for循環(huán)+
func BenchmarkForConcat(b *testing.B) {
for i := 0; i < b.N; i++ {
var s string
for i := 0; i < len(strs); i++ {
s += strs[i]
}
}
}
// strings.Join
func BenchmarkJoin(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = strings.Join(strs, "")
}
}
// strings.Builder
func BenchmarkBuilder(b *testing.B) {
for i := 0; i < b.N; i++ {
builder := strings.Builder{}
for i := 0; i < len(strs); i++ {
builder.WriteString(strs[i])
}
_ = builder.String()
}
}
// strings.Builder
func BenchmarkBuilderGrowFirst(b *testing.B) {
for i := 0; i < b.N; i++ {
builder := strings.Builder{}
n := 0
for i := 0; i < len(strs); i++ {
n += len(strs[i])
}
builder.Grow(n)
for i := 0; i < len(strs); i++ {
builder.WriteString(strs[i])
}
_ = builder.String()
}
}
// bytes.Buffer
func BenchmarkBuffer(b *testing.B) {
for i := 0; i < b.N; i++ {
buffer := bytes.Buffer{}
for i := 0; i < len(strs); i++ {
buffer.WriteString(strs[i])
}
_ = buffer.String()
}
}
// bytes.Buffer
func BenchmarkBufferGrowFirst(b *testing.B) {
for i := 0; i < b.N; i++ {
buffer := bytes.Buffer{}
n := 0
for i := 0; i < len(strs); i++ {
n += len(strs[i])
}
buffer.Grow(n)
for i := 0; i < len(strs); i++ {
buffer.WriteString(strs[i])
}
_ = buffer.String()
}
}
到此這篇關于go字符串拼接方式及性能比拼小結的文章就介紹到這了,更多相關go字符串拼接內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要為大家介紹了go?singleflight緩存雪崩源碼分析與應用示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-09-09
Golang中優(yōu)秀的消息隊列NSQ基礎安裝及使用詳解
這篇文章主要介紹了Golang中優(yōu)秀的消息隊列NSQ基礎安裝及使用詳解，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-12-12
這篇文章主要介紹了在其他一些編程語言中,如?C?語言,三元運算符是一種可以用一行代碼實現條件選擇的簡便方法,那么在Go語言中如何實現類似功能呢,下面就跟隨小編一起學習一下吧2024-02-02
golang中也實現了排序算法的包sort包，下面這篇文章就來給大家介紹了關于go語言中排序sort的使用方法，文中通過示例代碼介紹的非常詳細，需要的朋友可以參考借鑒，下面隨著小編來一起學習學習吧2018-06-06
深入學習Golang并發(fā)編程必備利器之sync.Cond類型
Go?語言的?sync?包提供了一系列同步原語，其中?sync.Cond?就是其中之一。本文將深入探討?sync.Cond?的實現原理和使用方法，幫助大家更好地理解和應用?sync.Cond，需要的可以參考一下2023-05-05
類型嵌入指的就是在一個類型的定義中嵌入了其他類型,Go?語言支持兩種類型嵌入,分別是接口類型的類型嵌入和結構體類型的類型嵌入,下面我們就來詳細一下類型嵌入的使用吧2023-11-11
viper?是?go?項目中用來讀取配置文件的庫，支持讀取?yaml、toml、json、hcl、env?等格式的配置文件，下面就來和大家聊聊它的具體使用吧2023-07-07
這篇文章主要介紹了golang 生成二維碼海報的實現代碼，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-02-02
性能優(yōu)化的前提是滿足正確可靠、簡潔清晰等質量因素，針對?Go語言特性，本文為大家整理了一些Go語言相關的性能優(yōu)化建議，感興趣的可以了解一下2023-07-07
gomock是Go編程語言的模擬框架, 它與Go的內置測試包很好地集成在一起,但也可以在其他上下文中使用,本文主要介紹了gomock的使用場景和方法,感興趣的可以了解下2024-10-10