Appendix E. Passing by value or by reference

This appendix clarifies how parameter passing works in Go and how it impacts program design. The central message is that Go always passes arguments by value, meaning every function call copies its parameters. The practical consequence is that mutating state across function boundaries requires passing pointers to share the same underlying data. It also highlights shallow copy pitfalls with pointer-typed fields, explains that methods follow the same rules as functions, and examines special container types—slices, maps, and channels—whose small headers hide internal pointers. The chapter concludes with pragmatic guidelines for choosing between values and pointers.

Mechanically, passing a struct by value creates a distinct copy, so changes made inside the callee do not affect the caller’s original. Passing a pointer copies only the pointer (type + address), preserving access to the same memory and enabling mutation. Because copies are shallow, a value parameter that contains pointer fields still points to the original data, making unintended updates possible if the pointees are modified. Methods are simply syntax over functions with an extra receiver parameter; the same value-versus-pointer trade-offs apply to method receivers.

Slices, maps, and channels are lightweight descriptors that reference underlying storage. As a result, functions can reorder slice elements or modify map/channel contents and those changes are visible to the caller, even though the descriptors themselves are passed by value. However, operations that change a slice’s length/capacity (such as append) must return the new slice. The recommendations are: prefer passing by value by default; use pointers when you need to mutate or for rare, measured performance reasons; avoid passing pointers to slices/maps/channels (return updated values instead), with narrow exceptions like unmarshalling into a slice; and consider writing explicit deep-copy functions when you must ensure no memory is shared.

FAQ