Array vs Slice — Go Benchmark

A fixed-size [1000]int array allocated on the stack. Each iteration writes to every index. Because the size is known at compile time, the compiler can elide bounds checks and the data stays contiguous in a single stack frame with zero heap allocations.

const size = 1000

func BenchmarkArray_run(b *testing.B) {
	var arr [size]int

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		for j := 0; j < size; j++ {
			arr[j] = j
		}
	}

	sink = arr[size-1]
}

Uses make([]int, 1000) to allocate the full backing array once before the benchmark loop. Each iteration writes to every index, similar to the array benchmark. The slice header adds a small overhead compared to a raw array, but avoids all growth-related allocations.

const size = 1000

func BenchmarkPreallocatedSlice_run(b *testing.B) {
	slice := make([]int, size)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		for j := 0; j < size; j++ {
			slice[j] = j
		}
	}

	sink = slice[size-1]
}

Starts with a nil slice and grows it via append on every element. Each time the underlying array runs out of capacity, the runtime allocates a larger backing array and copies existing elements over. This represents the worst case when the final size is unknown upfront.

const size = 1000

func BenchmarkDynamicSlice_run(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var slice []int
		for j := 0; j < size; j++ {
			slice = append(slice, j)
		}
		sink = slice[size-1]
	}
}