String Concatination

const (
	// setupCount is the number of writes during setup for read benchmarks.
	setupCount = 10_000
)

// BenchmarkSimpleAppend uses the + operator for string concatenation.
// Each append copies the entire string, making the total cost O(n²).
func BenchmarkSimpleAppend_write(b *testing.B) {
	var s string
	for i := 0; i < b.N; i++ {
		s += "a"
	}
	sink = s
}

func BenchmarkSimpleAppend_read(b *testing.B) {
	var s string
	for i := 0; i < setupCount; i++ {
		s += "a"
	}
	b.ResetTimer()

	// The result is already a string, so reading is essentially free.
	for i := 0; i < b.N; i++ {
		sink = s
	}
}

const (
	// setupCount is the number of writes during setup for read benchmarks.
	setupCount = 10_000
)

// BenchmarkStringBuilder uses strings.Builder which writes to an internal
// byte slice with amortized O(1) appends.
func BenchmarkStringBuilder_write(b *testing.B) {
	var s strings.Builder
	for i := 0; i < b.N; i++ {
		s.WriteString("a")
	}
	sink = s.String()
}

func BenchmarkStringBuilder_read(b *testing.B) {
	var s strings.Builder
	for i := 0; i < setupCount; i++ {
		s.WriteString("a")
	}
	b.ResetTimer()

	// String() uses an unsafe conversion, so it does not allocate.
	for i := 0; i < b.N; i++ {
		sink = s.String()
	}
}

const (
	// setupCount is the number of writes during setup for read benchmarks.
	setupCount = 10_000
)

// BenchmarkBuffer uses bytes.Buffer which writes to an internal byte slice
// with amortized O(1) appends, similar to strings.Builder.
func BenchmarkBuffer_write(b *testing.B) {
	var buf bytes.Buffer
	for i := 0; i < b.N; i++ {
		buf.WriteString("a")
	}
	sink = buf.String()
}

func BenchmarkBuffer_read(b *testing.B) {
	var buf bytes.Buffer
	for i := 0; i < setupCount; i++ {
		buf.WriteString("a")
	}
	b.ResetTimer()

	// String() copies the internal buffer into a new string (allocates).
	for i := 0; i < b.N; i++ {
		sink = buf.String()
	}
}

const (
	// setupCount is the number of writes during setup for read benchmarks.
	setupCount = 10_000
)

// BenchmarkAppendToSliceAndJoin collects strings in a slice and uses
// strings.Join to produce the final result.
func BenchmarkAppendToSliceAndJoin_write(b *testing.B) {
	var s []string
	for i := 0; i < b.N; i++ {
		s = append(s, "a")
	}
	sink = strings.Join(s, "")
}

func BenchmarkAppendToSliceAndJoin_read(b *testing.B) {
	var s []string
	for i := 0; i < setupCount; i++ {
		s = append(s, "a")
	}
	b.ResetTimer()

	// Join iterates through all elements and allocates the final string.
	for i := 0; i < b.N; i++ {
		sink = strings.Join(s, "")
	}
}