Use byte.Buffer for huge string appends

[ivanburak]

Hi stanNthe5

Good code and this message isn't an issue. It's just info.

strings.Builder is good for small amount of string writings into one buffer.
If you'd like to write hundred-thousand times into a buffer it will be better to use bytes.Buffer.
You can look at the third line in Benchmarks, it looks good :)

strSlice_vs_strBuilder>go test -bench .
goos: windows
goarch: amd64
pkg: github.com/stanNthe5/stringbuf
cpu: Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
BenchmarkStringBuf_Append-8                16274             71824 ns/op          283066 B/op         16 allocs/op
BenchmarkStringsBuilder_Append-8            6300            181336 ns/op          906771 B/op         22 allocs/op
BenchmarkByteBuffer_Append-8               17455             69732 ns/op          409601 B/op          2 allocs/op
PASS
ok      github.com/stanNthe5/stringbuf  3.640s

---

The whole code is below (I changed the algorithm by saving a random substring to avoid possible optimization by Go and removed Prepend-s)

start, end := substringIdx() 
... 
   sample[start:end])

package stringbuf

import (
	"bytes"
	"math/rand/v2"
	"strings"
	"testing"
)

const sample = "abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij"
const times = 2000
const half = len(sample) / 2

// stringbuf
func BenchmarkStringBuf_Append(b *testing.B) {
	b.ReportAllocs()
	b.ResetTimer()
	for b.Loop() {
		var sb StringBuf
		start, end := substringIdx()
		for range times {
			sb.Append(sample[start:end])
		}
		_ = sb.String()
	}
}

// strings.Builder
func BenchmarkStringsBuilder_Append(b *testing.B) {
	b.ReportAllocs()
	b.ResetTimer()
	for b.Loop() {
		var sb strings.Builder
		start, end := substringIdx()
		for range times {
			sb.WriteString(sample[start:end])
		}
		_ = sb.String()
	}
}

// bytes.Buffer
func BenchmarkByteBuffer_Append(b *testing.B) {
	b.ReportAllocs()
	b.ResetTimer()
	for b.Loop() {
		var sb bytes.Buffer
		sb.Grow(half * times)
		start, end := substringIdx()
		for range times {
			sb.WriteString(sample[start:end])
		}
		_ = sb.String()
	}
}

func substringIdx() (start, end int) {
	start = rand.IntN(half)
	end = start + half
	return
}

[stanNthe5]

Hi,
Thank you for your feedback.

The bytes.Buffer. is faster in the benchmark because it used Grow() before appending strings. Grow() also works on strings.Builder. If you can estimate the final size of a string, it not recommended to use stringbuf, because no one could be faster than strings.Builder if you preset enough memory by Grow().