Go Variables & Constants - Core Mechanics

Variables & Constants

Category: Fundamental Core Topic: State & Data Structures

Concept

Variables hold values that may change during program execution. Constants hold values that never change, determined at compile time. Go has a distinct := short variable declaration operator and var explicit declaration. Every variable has a zero value if not explicitly initialized. Constants can be character, string, or boolean numerics, and support iota for enum-like sequences.

Why It Exists

Variables and constants are the foundation of state management in any language. Go's approach emphasizes:

Explicit declaration: var makes it clear what variables are created at package level vs function level.
Zero-value safety: Uninitialized variables still have defined values (0, false, ""), preventing nil pointer dereferences from uninitialized variables.
Compile-time constants: const values are evaluated at compile time, allowing use in contexts requiring constants (e.g., array sizes, case labels).
iota: Provides a way to generate related constant values without manual repetition, reducing maintenance burden.

How It Works

Variable Declaration

Three primary forms with subtle differences:

// Form 1: var with explicit type
var i int = 42

// Form 2: var with type inference
var j = 42 // i int, j int

// Form 3: short declaration (:=) - at least one new variable on left
k := 42 // new variable k

// Form 4: short with existing var
i := 10 // reuses existing i if in same scope

Short declaration rules (:=):

At least one variable on the left side must be new (not already declared in the same scope).
If i already exists, i := 5 just reassigns it if paired with a new variable on the left.
If i doesn't exist, i := 5 declares it.
Cannot use := to reassign a variable without declaring a new one in the same scope.

Constants & `iota`

const Pi = 3.14
const World = "Hello, Universe"
const AmericanFlagStars = 50
const True = true

// iota-based sequence
const (
    Unknown = iota // 0
    Female         // 1
    Male           // 2
)

Starts at 0, increments by 1 for each line in a const block.
Can be reset with explicit assignment: const (a = iota, b = iota) → a=0, b=1.
Can be used with bit shifts: const (c = iota << 3, d = iota << 3) → c=0, d=8.
iota is reset for each distinct const block.

Zero Values

If a variable is declared but not explicitly assigned, it receives a zero value:

Type	Zero Value
`int`, `uint`, `float`, `complex`	`0`
`bool`	`false`
`string`	`""` (empty string)
`pointer`, `interface`, `function`, `slice`, `map`, `channel`	`nil`
`struct`	All fields zero-valued
`array`	All elements zero-valued

`const` vs `var`

Aspect	`const`	`var`
Evaluation	Compile-time	Runtime
Type inference	Implicit untyped literals	Optional
Usage	Array sizes, case labels, constants	Dynamic state allocation
Number of values	Fixed at compile time	Can change dynamically
Memory layout	Inlined into instruction stream	Allocated on stack/heap

Code Example

package main

import "fmt"

// Constants - compile-time
const (
    StatusOK       = 200
    StatusBadReq   = 400
    StatusNotFound = 404
    MaxAttempts    = 3
)

// iota example
const (
    Sunday = iota // 0
    Monday        // 1
    Tuesday       // 2
    Wednesday     // 3
    Thursday      // 4
    Friday        // 5
    Saturday      // 6
)

// const with explicit reset
const (
    a = iota // 0
    b = iota // 1
    c = 42   // 42, iota pauses expression evaluation
    d = iota // 3 (resumes sequence index)
)

// Runtime package-level variable
var runtimeVar = "I am a runtime variable"

func main() {
    _ = StatusOK
    _ = Sunday
    _ = a
    _ = c
    
    var explicitVar int = 7
    implicitVar := "inferred type"
    
    fmt.Println("Status OK:", StatusOK)
    fmt.Println("Monday:", Monday)
    fmt.Println("c value:", c)
    fmt.Println("runtimeVar:", runtimeVar)
    fmt.Println("implicitVar:", implicitVar)
    
    // Zero value demonstration
    var zeroInt int        // 0
    var zeroBool bool      // false
    var zeroString string  // ""
    fmt.Printf("zeroInt=%v, zeroBool=%v, zeroString='%v'\n", zeroInt, zeroBool, zeroString)
}

Step-by-Step Execution

Consider the compilation and execution flow for the following sample:

package main

import "fmt"

const (
    a = iota      // 0
    b = iota      // 1
    c = 42        // 42, iota pauses
    d = iota      // 3 (resumes)
)

func main() {
    x := 5          // short declares x
    var y int       // zero value 0
    _ = a + b + c + d // use constants
    fmt.Println(x, y)
}

Package Level: Constants a, b, c, d are compiled into the binary as literal values. iota is evaluated once at compile time.
main() Execution Step 1: x := 5 declares local variable x typed as int and assigns value 5.
main() Execution Step 2: var y int allocates integer stack memory initialized automatically to zero value 0.
main() Execution Step 3: Expression a + b + c + d resolves directly to 0 + 1 + 42 + 3 = 46 at compile time; runtime discards output via _.
main() Execution Step 4: fmt.Println(x, y) outputs 5 0 to standard stdout.

Internals

Memory Layout

Stack-allocated variables: Function-local variables (y := 5) reside on the active goroutine stack. Frame sizes are calculated at compile time.
Package-level variables: Stored in the static data segment (.data/.bss) of the executable binary. Initialized before main() execution.
Constants: Inlined into compiler-generated machine instructions. No heap or stack addresses are created for simple constants.

`iota` Implementation

iota is an internal parser sequence counter. The compiler tracks line-index shifts within the current AST const specification block, replacing references directly with resolved literal integers before final emission.

Short Declaration (`:=`) Desugaring

The frontend compiler translates := into explicit variable declarations and scope assignment passes while enforcing that at least one identifier on the left-hand side is newly introduced into the block scope.

Complexity Matrix

Aspect	Complexity	Description
Variable declaration	`O(1)`	Stack pointer advancement.
Constant evaluation	`O(1)`	Folded during compilation.
`iota` increment	`O(1)`	Static parser AST index step.
Zero value assignment	`O(1)`	Direct stack memory clearing pass.

Common Mistakes

Reassignment using :=: Invoking := when all left-hand identifiers are already declared in the current scope triggers a compile error.
Expecting runtime evaluation in const: Attempting to assign function call results (e.g., const x = time.Now()) fails to compile.
Cross-block iota assumptions: Assuming iota retains state across separate const ( ... ) declarations.
Missing parentheses: Writing un-grouped multi-constant iota statements leads to syntax errors or unexpected resets.

Production Considerations

Use const for magic values: Standardize system bounds (e.g., const MaxRetries = 3) to prevent literal spreading.
Define Enums via iota: Pair iota with custom defined types (e.g., type Priority int) to establish strict type-checked enums.
Group related declarations: Utilize parenthesized blocks for clean grouping and maintainable maintenance.

Interview Preparation

Beginner Track

var i int explicitly declares a variable with a zero value (0), whereas i := 5 uses type inference to declare and initialize in one short statement inside functions.

The default guaranteed value assigned by the compiler to uninitialized variables (e.g., 0 for numbers, "" for strings, false for booleans, nil for pointers/slices/maps).

Senior Track

Constants are inlined directly into CPU instruction streams without runtime allocations. Variables require dedicated stack/heap memory locations and GC management.

Follow-Up Questions

Can you use iota with custom string representations cleanly?
What happens when a short variable declaration shadows a package-level variable?
Is it possible to declare a const slice or map in Go? Why or why not?

Practical Exercise

// Blueprint: Implement an HTTP Status & Day-of-Week checker using iota & consts
package main

import "fmt"

type Day int

const (
    Sunday Day = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

const (
    StatusOK       = 200
    StatusNotFound = 404
)

func isValidStatus(code int) bool {
    return code >= 100 && code <= 599
}

func main() {
    fmt.Println("Monday Index:", Monday)
    fmt.Println("Is 200 Valid:", isValidStatus(StatusOK))
}

Comments