Variables & Constants

package main

import "fmt"

// Package-level variable (lives for the program's lifetime)
var globalCounter int = 0

func main() {
    // Function-level variable with explicit type
    var name string = "Alice"
    var age  int    = 30
    var isAdmin bool = true

    // Multiple variables in one var block (common for related variables)
    var (
        host string = "localhost"
        port int    = 8080
        tls  bool   = false
    )

    fmt.Printf("name=%s age=%d admin=%v\n", name, age, isAdmin)
    fmt.Printf("host=%s port=%d tls=%v\n", host, port, tls)
}
// When to use: package-level variables, when you want the type visible for clarity

func main() {
    // Go infers the type from the right-hand side
    var name    = "Alice"    // inferred as string
    var age     = 30         // inferred as int
    var pi      = 3.14159    // inferred as float64
    var done    = false      // inferred as bool
    var letter  = 'A'        // inferred as int32 (rune)

    // What type did Go infer? Use %T to find out
    fmt.Printf("%T\n", name)    // string
    fmt.Printf("%T\n", age)     // int
    fmt.Printf("%T\n", pi)      // float64
    fmt.Printf("%T\n", letter)  // int32

    _ = done // suppress "declared and not used" error
}

func main() {
    // Short declaration — type inferred, cannot be used at package level
    name := "Alice"
    age  := 30
    pi   := 3.14

    // Multiple assignment
    x, y := 10, 20

    // Swap values elegantly
    x, y = y, x  // Note: = not :=  (both already declared)

    fmt.Printf("%s is %d years old\n", name, age)
    fmt.Println("pi =", pi)
    fmt.Printf("x=%d y=%d (after swap)\n", x, y)

    // Re-declaring with := (valid if at least ONE new variable on left)
    val, err := doSomething()  // both new
    val, err = doSomethingElse() // neither new — use = not :=
    newVal, err := doThird()    // newVal is new, err is re-used — valid :=
    _ = val; _ = newVal; _ = err
}

func doSomething() (int, error)     { return 1, nil }
func doSomethingElse() (int, error) { return 2, nil }
func doThird() (int, error)         { return 3, nil }

package main

import (
    "fmt"
    "strconv"
)

func divide(a, b int) (int, int, error) {
    if b == 0 {
        return 0, 0, fmt.Errorf("division by zero")
    }
    return a / b, a % b, nil
}

func main() {
    // Discard the remainder with _
    quotient, _, err := divide(10, 3)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Quotient:", quotient)  // 3

    // Discard the error (NOT recommended in production — shown for illustration)
    n, _ := strconv.Atoi("42")
    fmt.Println(n)  // 42

    // _ can also discard import side effects:
    // import _ "github.com/lib/pq"  // registers PostgreSQL driver
}

package main

import "fmt"

type Config struct {
    Host    string  // zero: ""
    Port    int     // zero: 0
    TLS     bool    // zero: false
    Timeout float64 // zero: 0.0
    Tags    []string // zero: nil (but safe to use)
}

func main() {
    var c Config
    // No need to set every field — zero values are safe
    fmt.Printf("Host:    %q\n", c.Host)      // ""
    fmt.Printf("Port:    %d\n", c.Port)      // 0
    fmt.Printf("TLS:     %v\n", c.TLS)       // false
    fmt.Printf("Tags:    %v (nil=%v)\n", c.Tags, c.Tags == nil) // [] (nil=true)
    fmt.Printf("len(Tags): %d\n", len(c.Tags)) // 0 — safe on nil slice!

    // Zero value makes sync.Mutex immediately usable:
    // var mu sync.Mutex  ← this just works, no New() needed
}

package main

import "fmt"

// Typed constant — has a fixed type
const MaxRetries int = 3
const Pi float64 = 3.14159265358979323846

// Untyped constant — extremely precise, type inferred at use
const E = 2.71828182845904523536 // untyped floating-point
const Greeting = "Hello"          // untyped string
const Big = 1 << 62               // untyped integer (huge precision)

// Constant block
const (
    StatusOK    = 200
    StatusNotFound = 404
    StatusError    = 500
)

// Constants can be expressions (evaluated at compile time)
const (
    KB = 1024
    MB = 1024 * KB
    GB = 1024 * MB
    TB = 1024 * GB
)

func main() {
    fmt.Printf("1 KB = %d bytes\n", KB)
    fmt.Printf("1 GB = %d bytes\n", GB)
    fmt.Printf("Pi = %v\n", Pi)

    // Untyped constant adapts to context
    var x float32 = E  // E (untyped) assigned to float32
    var y float64 = E  // E (untyped) assigned to float64
    fmt.Printf("float32: %v, float64: %v\n", x, y)
}

package main

import "fmt"

// Basic iota — 0, 1, 2, 3
type Weekday int
const (
    Sunday Weekday = iota  // 0
    Monday                  // 1 (iota is implicitly repeated)
    Tuesday                 // 2
    Wednesday               // 3
    Thursday                // 4
    Friday                  // 5
    Saturday                // 6
)

// iota with arithmetic — bit flags (extremely common pattern)
type Permission uint
const (
    Read    Permission = 1 << iota  // 1 << 0 = 1  (0001)
    Write                            // 1 << 1 = 2  (0010)
    Execute                          // 1 << 2 = 4  (0100)
    Admin                            // 1 << 3 = 8  (1000)
)

// Skip a value with _
type Level int
const (
    _        = iota  // 0: unused/discard (sentinel)
    Low  Level = iota  // 1
    Mid                // 2
    High               // 3
)

// iota in expressions
const (
    _  = iota             // 0: skip
    KB = 1 << (10 * iota) // 1 << 10 = 1024
    MB                     // 1 << 20 = 1048576
    GB                     // 1 << 30 = 1073741824
)

func (d Weekday) String() string {
    names := [...]string{"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}
    if d < Sunday || d > Saturday {
        return fmt.Sprintf("Weekday(%d)", d)
    }
    return names[d]
}

func main() {
    today := Wednesday
    fmt.Println("Today is", today)  // Today is Wednesday

    // Combining permissions with bitwise OR
    myPerms := Read | Write
    fmt.Printf("Permissions: %04b (%d)\n", myPerms, myPerms)  // 0011 (3)

    // Checking permissions with bitwise AND
    if myPerms&Write != 0 {
        fmt.Println("Has write permission ✓")
    }
    if myPerms&Execute == 0 {
        fmt.Println("No execute permission ✗")
    }

    fmt.Printf("1KB = %d, 1MB = %d, 1GB = %d\n", KB, MB, GB)
}

package main

import "fmt"

var packageLevel = "I am visible throughout this package" // package scope

func scopeDemo() {
    funcLevel := "I am visible in this function" // function scope

    {   // inner block
        blockLevel := "I am only visible in this block"
        fmt.Println(blockLevel)
        fmt.Println(funcLevel)    // can access outer scope
        fmt.Println(packageLevel) // can access package scope
    }
    // fmt.Println(blockLevel)  // ← compile error: undefined: blockLevel

    // if statement creates its own scope
    if x := computeValue(); x > 0 { // x is scoped to this if block!
        fmt.Println("positive:", x)
    }
    // fmt.Println(x)  // ← compile error: undefined: x (out of if scope)

    // for loop variable scope
    for i := 0; i < 3; i++ {
        // i is scoped to the for loop
        _ = i
    }
    // fmt.Println(i)  // ← compile error

    fmt.Println(funcLevel)
}

func computeValue() int { return 42 }

func main() {
    scopeDemo()
}

package main

import "fmt"

func shadowingBug() {
    err := doStep1()     // outer err

    if true {
        result, err := doStep2()  // ← THIS SHADOWS outer err!
        // A new 'err' is created inside this block.
        // The outer 'err' is still the one from doStep1.
        fmt.Println(result, err)
    }

    // Bug: you might think err was updated above, but it wasn't
    if err != nil { // ← this checks the ORIGINAL err from doStep1
        fmt.Println("Error from step 1:", err)
    }
}

// The correct way — use = not := to update the outer variable:
func correctVersion() {
    var result int
    err := doStep1()

    if true {
        var e error
        result, e = doStep2()  // assign to existing variables
        if e != nil {
            err = e  // explicitly update the outer err
        }
        fmt.Println(result)
    }

    if err != nil {
        fmt.Println("Error:", err)
    }
}

// Another common shadowing trap: err shadowed in a loop
func loopShadowing() {
    var outerErr error

    for i := 0; i < 3; i++ {
        // This := creates a new err each iteration, doesn't update outerErr
        _, err := doSomethingN(i)
        if err != nil {
            outerErr = err  // must explicitly assign to outer
        }
    }

    if outerErr != nil {
        fmt.Println("Loop error:", outerErr)
    }
}

func doStep1() error           { return nil }
func doStep2() (int, error)    { return 0, nil }
func doSomethingN(int) (int, error) { return 0, nil }

func main() {
    shadowingBug()
    correctVersion()
    loopShadowing()
}

# Install and use the shadow analyser
go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow@latest
shadow ./...

package main

// Case 1: Variable stays on stack — doesn't escape
func noEscape() int {
    x := 42    // x is used only within this function
    return x   // returning the VALUE, not a pointer — x stays on stack
}

// Case 2: Variable escapes to heap — returned pointer
func escapes() *int {
    x := 42     // x must live beyond this function's return
    return &x   // returning a POINTER — x escapes to heap
}

// Case 3: Escapes via interface — common source of heap allocations
func escapesViaInterface() interface{} {
    x := 42
    return x   // Storing in interface{} causes escape in most cases
}

// Case 4: Escapes via slice/map storage
func escapesViaSlice() {
    s := make([]int, 10)
    for i := range s {
        val := i * 2
        s[i] = val  // val might escape if slice escapes
    }
    _ = s
}

func main() {
    a := noEscape()   // a on stack
    b := escapes()    // *b on heap, b (the pointer) on stack
    _ = a; _ = b
}

# Inspect escape analysis decisions
go build -gcflags="-m" main.go

# Output will tell you what escaped:
# ./main.go:11:2: x escapes to heap
# ./main.go:6:2: x does not escape
# ./main.go:17:2: x escapes to heap (interface conversion)

# More verbose output:
go build -gcflags="-m -m" main.go

package main

// ❌ MISTAKE 1: Declared variable never used
func unused() {
    x := 42  // compile error: x declared and not used
}

// ❌ MISTAKE 2: Assuming := updates an outer variable
func shadowErr() error {
    err := doSomething()
    if true {
        result, err := doMore()  // BUG: shadows outer err
        _ = result; _ = err
    }
    return err  // this is the original err, not the one from doMore()
}

// ❌ MISTAKE 3: Thinking short int literals are int64
func intSizeAssumption() {
    x := 42        // x is int (platform-dependent: 32 or 64 bits)
    var y int64 = x // compile error: cannot use x (int) as int64
    _ = y
}

// ✅ FIX for mistake 3:
func intSizeFixed() {
    x := int64(42)   // explicit conversion
    var y int64 = 42 // or explicit type declaration
    _, _ = x, y
}

// ❌ MISTAKE 4: Modifying a nil map
func nilMap() {
    var m map[string]int  // m is nil
    m["key"] = 1          // PANIC: assignment to entry in nil map
}

// ✅ FIX:
func nilMapFixed() {
    m := make(map[string]int)  // initialise with make
    m["key"] = 1               // now safe
}

func doSomething() error  { return nil }
func doMore() (int, error) { return 0, nil }

func main() {}