テストケース

以下のような9文字*10要素の文字列の配列要素を","で結合し、最後に","を追記するコードを実装した。得たい出力はstringなので、[]byteやbytes.Bufferを使う場合、最後にstringへのキャストを実行した。

var m = [...]string{
	"AAAAAAAAA",
	"AAAAAAAAA",
	"AAAAAAAAA",
	"AAAAAAAAA",
	"AAAAAAAAA",
	"AAAAAAAAA",
	"AAAAAAAAA",
}

使用したコードはこちら：Golang string join benchmark

実装

+=演算子のループ

ナイーブな実装。遅い。

func BenchmarkAppendOperator_(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var m2 string
		for _, v := range m {
			m2 += m2 + "," + v
		}
		m2 += ","
	}
}
// BenchmarkAppendOperator	 1000000	      3043 ns/op	    3808 B/op	       8 allocs/op

結果：3043ns/op

strings.Join関数

strings.Joinを使った方法。

func BenchmarkStringsJoin(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = strings.Join(m[:], ",") + ","
	}
}
// BenchmarkStringsJoin	 5000000	       413 ns/op	     240 B/op	       3 allocs/op

結果：413ns/op

一度の代入文で+演算子で全要素を結合

一度の代入文で全ての要素を結合するようハードコーディングする。strings.joinよりもアロケーションが少なく高速

func BenchmarkHardCoding(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = m[0] + "," + m[1] + "," + m[2] + "," + m[3] + "," + m[4] + "," + m[5] + "," + m[6]
	}
}
// BenchmarkHardCoding	10000000	       216 ns/op	      80 B/op	       1 allocs/op

結果：216ns/op

[]byte

var m2 []byteで宣言した[]byteにappend()を繰り返す。strings.Joinよりも遅くなっている。

func BenchmarkByteArray(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var m2 []byte
		for _, v := range m {
			m2 = append(m2, v...)
			m2 = append(m2, ',')
		}
		_ = string(m2)
	}
}
// BenchmarkByteArray______	 5000000	       613 ns/op	     320 B/op	       5 allocs/op

結果：613ns/op

キャパシティ指定付き[]byte

var m2 = make([]byte, 0, 100) で[]byteに100byteのキャパシティを確保したところ、アロケーションが少なくなり、この方法が一番高速だった。最後のstringへのキャストを除くとアロケーションは0になる。


func BenchmarkCapByteArray___(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var m2 = make([]byte, 0, 100)
		for _, v := range m {
			m2 = append(m2, v...)
			m2 = append(m2, ',')
		}
		_ = string(m2)
	}
}
// BenchmarkCapByteArray___	10000000	       171 ns/op	      80 B/op	       1 allocs/op

結果：171ns/op

bytes.Buffer

bytes.Buffer を使ってみる

func BenchmarkBytesBuffer____(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var m2 bytes.Buffer
		for _, v := range m {
			m2.Write([]byte(v))
			m2.Write([]byte{','})
		}
		_ = m2.String()
	}
}
// BenchmarkBytesBuffer____	 1000000	      1074 ns/op	     449 B/op	      10 allocs/op

(結果:1074 ns/op)

キャパシティ指定付き bytes.Buffer

NewBufferにキャパシティ指定した[]byteを渡してみる。

func BenchmarkCapBytesBuffer_(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var m2 = bytes.NewBuffer(make([]byte, 0, 100))
		for _, v := range m {
			m2.Write([]byte(v))
			m2.Write([]byte{','})
		}
		_ = m2.String()
	}
}
// BenchmarkCapBytesBuffer_	 2000000	       956 ns/op	     419 B/op	      10 allocs/op

(結果:956ns/op)

キャパシティ指定付き bytes.Buffer + WriteString

Buffer.WriteのかわりにBuffer.WriteStringというメソッドを使ってみたところ、Buffer.Writeよりも速くなった。

func BenchmarkCapBytesBuffer2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var m2 = bytes.NewBuffer(make([]byte, 0, 100))
		for _, v := range m {
			m2.WriteString(v)
			m2.WriteString(",")
		}
		_ = m2.String()
	}
}
// BenchmarkCapBytesBuffer2	 5000000	       588 ns/op	     307 B/op	       3 allocs/op

結果:588ns/op

結果一覧

BenchmarkAppendOperator_	 1000000	      3043 ns/op	    3808 B/op	       8 allocs/op
BenchmarkStringsJoin____	 5000000	       413 ns/op	     240 B/op	       3 allocs/op
BenchmarkHardCoding_____	10000000	       216 ns/op	      80 B/op	       1 allocs/op
BenchmarkByteArray______	 5000000	       613 ns/op	     320 B/op	       5 allocs/op
BenchmarkCapByteArray___	10000000	       171 ns/op	      80 B/op	       1 allocs/op
BenchmarkBytesBuffer____	 1000000	      1074 ns/op	     449 B/op	      10 allocs/op
BenchmarkCapBytesBuffer_	 2000000	       956 ns/op	     419 B/op	      10 allocs/op
BenchmarkCapBytesBuffer2	 5000000	       588 ns/op	     307 B/op	       3 allocs/op

知見

大まかに各手法での処理時間を比べると、このような感じ。

[]byte < ハードコーディング(200ns) < strings.Join(400ns) < bytes.Buffer(600ns) < +=演算子ループ(2900ns)

+=演算子ループはやはり一桁遅い。
- ただし文字列の+演算子は特に遅いと言う事は無いので、s := a + b + c のように、一度の代入で複数の結合を行うのは十分に高速
bytes.Bufferより[]byteの方が高速
makeで十分なキャパシティを確保してalloc回数を下げるのが重要
bytes.Bufferでstringを結合する場合は、Write()よりWriteString()が高速
Goはこういうベンチマークがサッと書けるので良い