Master Go Pointers: Best Practices, Performance Tips, and Code Review Checklist

1. Why Go pointers matter?

Pointers in Go are a powerful tool that enable you to modify variables outside a function, avoid copying large structs, represent optional fields, and build data structures such as linked lists, trees, and graphs.

Modify external variables

Avoid copying large structs

Represent optional fields

Construct linked lists, trees, graphs

Misusing pointers can lead to nil‑dereference crashes, unnecessary copying that hurts performance, and reduced readability and maintainability. nil crashes

Unnecessary copies degrade performance

Readability and maintainability suffer

Technical tip: In Go, pointers are safe references managed by the garbage collector, not dangerous raw pointers. Understanding their underlying mechanism is key to avoiding pitfalls.

2. Go pointer basics and underlying mechanisms

Definition : A pointer stores the memory address of a variable and has type *T.

Address‑of operator : &x obtains the address of x.

Dereference : *p accesses the value pointed to by p.

Safety : Go forbids pointer arithmetic, preventing dangling pointers common in C/C++.

2.1 Stack vs. heap escape analysis

Local variable x is usually allocated on the stack, but if its address escapes the function, it is moved to the heap and tracked by the GC. Understanding escape analysis helps write high‑performance code.

func foo() *int {
    x := 42
    return &x // x escapes to heap
}

2.2 Relationship between pointers and values

*p

directly manipulates memory.

Passing values copies the entire object.

Use pointers for large structs, frequent modifications, or optional fields.

3. Pointer best‑practice checklist ✅

3.1 Modify external variables

func setValue(p *int) { *p = 42 }

3.2 Avoid copying large structs

type BigData struct { Payload [1024]int }
func process(data *BigData) { /* pointer avoids copy */ }

3.3 Method receivers modify fields

type User struct { Name string }
func (u *User) SetName(name string) { u.Name = name }

3.4 Optional fields

type Config struct { Timeout *int } // nil means not set

3.5 Linked list / tree / graph nodes

type Node struct {
    Val  int
    Next *Node
}

4. When not to use pointers ❌

4.1 Small objects (basic types)

func square(x int) int { return x * x } // copy cost is negligible

4.2 slice / map / channel

These are already reference types; additional pointers are unnecessary.

func updateSlice(s []int) { s[0] = 99 }

4.3 Read‑only scenarios

func printUser(u User) { fmt.Println(u.Name) } // pass by value is fine

5. Engineering considerations ⚠️

nil safety : Always check for nil before dereferencing.

Performance : Escape analysis influences allocation decisions.

Zero value vs. unset : Use pointer fields to distinguish missing values.

Readability first : Avoid overusing pointers.

GC interaction : Pointers are tracked; unnecessary references can prolong object lifetimes.

6. Code Review quick checklist 🕵️‍♂️

Does the function modify external variables? → Yes ✅ use pointer | No → continue
Is the struct large? → Yes ✅ use pointer | No → continue
Is it a slice/map/chan? → Yes ❌ use value | No → continue
Is it an optional field? → Yes ✅ use pointer | No → continue
Is it read‑only? → Yes ❌ use value | No → continue
Is there a nil‑safety check? → No ⚠️ add it

7. Pointer to array & pointer to pointer

Useful for complex data structures or multi‑level linking, but remember nil checks.

var arr [3]*int
for i := range arr {
    arr[i] = new(int)
    *arr[i] = i
}

var pp **int
x := 42
p := &x
pp = &p
fmt.Println(**pp) // 42

8. Pointers vs. slice/map/chan/interface

slice, map, chan, and interface are reference types.

Pass a pointer only when you need to modify the container itself or avoid copying a large object.

Do not add extra pointers to collection types; it hurts readability.

9. Performance comparison example

type BigData struct { Payload [1024]int }

func valueProcess(data BigData) {}
func pointerProcess(data *BigData) {}

// Benchmarks typically show the pointer version is faster, especially in tight loops or frequent calls.

10. Summary

Go pointers are safe and efficient when used correctly. Mastering them helps you reduce large‑object copies, safely modify external variables, represent optional fields, and build complex data structures.

Use pointers for mutable, large, or optional data.

Use values for small objects, read‑only data, and collection types.

Always perform nil checks and consider GC impact.

One‑line mnemonic: mutable + large + optional → pointer; small + read‑only + collection → value or reference.