Mastering Go Variable Declarations: Choosing Between var and :=

Go do zero: var vs :=

Go provides two distinct ways to declare variables, var and :=, each governed by specific scope and initialization rules. Using the short variable declaration := outside of a function body will result in an immediate compilation failure.

Why This Matters

In technical Go development, choosing the wrong declaration method can lead to subtle logic errors through variable shadowing or unnecessary memory allocation. While the short declaration offers brevity for local scope, the var keyword is essential for package-level state and zero-value initialization, ensuring type safety and memory efficiency in high-performance applications.

Key Insights

• The var keyword allows for explicit zero-value initialization, such as var users []string which creates a nil slice without allocation.
• Short variable declaration := is restricted exclusively to function scopes and cannot be used at the package level.
• The := operator permits redeclaration within the same block if at least one variable on the left side is new and types remain consistent.
• Type inference with nil is impossible without an explicit type, as seen in var n *int = nil vs the failing var n = nil.
• The blank identifier _ enables discarding function returns to satisfy Go’s strict no unused variables compilation rule.

Working Examples

Standard variable declarations using the var keyword.

var x int // zero value
var y int = 5 // type and value
var z = 5 // inferred
var (
    a int
    b string = "hi"
)

Short variable declaration syntax for use within functions.

x := 5
a, b := 1, "hello"
ch := make(chan int)
v, ok := m[key]

Pattern showing redeclaration using := when at least one new variable is introduced.

field, offset := nextField(s, 0)
field, offset = nextField(s, offset) // assignment
field2, offset := nextField(s, offset) // redeclaration of offset

The shadowing pitfall where := in a nested scope creates a new variable instead of updating the existing one.

err := outer()
if true {
    err := inner() // shadowing: new variable in inner block
    _ = err
}
// err here is still the result of outer()

Practical Applications

• Package Configuration: Use var for global constants or versioning strings where := is prohibited by the compiler.
• Error Handling: Use := for receiving multiple return values like data, err := os.ReadFile(“config.yaml”) to keep code concise.
• Local Scope Control: Utilize the if v, ok := m[“k”]; ok pattern to limit variable lifetime and prevent namespace pollution.
• Pitfall: Avoid using := in nested blocks for existing variables, which causes shadowing and often leads to unexpected application behavior.

References:

• https://dev.to/oliversieto/go-do-zero-var-vs—398e