golang-data-structures

Go slices grow by allocating a new backing array and copying elements when capacity is exceeded. Preallocate slice capacity using the make function with a known or estimated length to avoid repeated memory allocation and copying overhead during sequential appends.

Go maps with value semantics copy data on access, increasing memory overhead, while pointer semantics store references to avoid large struct duplication. Choose pointer types for large structs to minimize memory usage and reduce garbage collection pressure during map operations.

Use Go arrays instead of slices when the data size is fixed and known at compile time, as arrays avoid heap allocation. Slices are preferred for dynamic sizing, but arrays provide predictable memory layout and zero allocation overhead for fixed-length data.

Go generics allow defining type-safe data structures like slices and maps without interface{} boxing. Apply type parameters to functions and structs to enforce compile-time type safety, eliminating runtime type assertions and reducing memory overhead in generic algorithms.

Using the unsafe package in Go bypasses the memory model, risking memory corruption and unpredictable garbage collection behavior. Avoid unsafe pointer arithmetic unless absolutely necessary for zero-allocation reads, and always document safe usage patterns to prevent memory leaks.

Zero-allocation reads in Go maps prevent heap growth and reduce garbage collection pauses. Using pointer semantics and avoiding unnecessary struct copies during map lookups minimizes memory allocations, which is critical for maintaining high throughput in performance-critical code.