
Go has two ways to declare variables: the `var` keyword (explicit type, works anywhere) and the short variable declaration `:=` (inferred type, inside functions only). Both are valid - use `var` at package scope or when you want to name the type explicitly; use `:=` inside functions for brevity.

<ExamplePair>
<ExampleProse>

`var` declares a variable with an explicit or inferred type. When no initial value is given, the variable is set to its zero value - `0` for numbers, `false` for booleans, `""` for strings, and `nil` for pointers, slices, maps, channels, and functions.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

var globalCount int // zero value: 0

func main() {
    var x int         // 0
    var s string      // ""
    var b bool        // false

    fmt.Println(x, s, b)  // 0  false
    fmt.Println(globalCount) // 0
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Inside a function, `:=` declares and initialises in one step. The compiler infers the type from the right-hand side.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    name := "Alice"   // string
    age := 30         // int
    active := true    // bool

    fmt.Println(name, age, active)

    // Multiple assignment in one line
    x, y := 1, 2
    fmt.Println(x + y) // 3

    // Swap without a temp variable
    x, y = y, x
    fmt.Println(x, y)  // 2 1
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

When declaring several related variables together, the `var` block form is readable and avoids repetition.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    var (
        host = "localhost"
        port = 5432
        ssl  = false
    )
    fmt.Println(host, port, ssl)
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Zero values are a deliberate design feature, not an oversight. A struct field you forget to initialise is not a nil panic - it's a predictable zero. This makes Go programs more robust by default, but it also means that "is this value set?" requires a sentinel or a separate boolean flag, not a nil check. Know your types' zero values before adding defensive nil checks that paper over bad initialisation. The pattern `if cfg.Timeout == 0 { cfg.Timeout = defaultTimeout }` is idiomatic Go.
</InProduction>


var declarations, short variable declaration :=, zero values, and multiple assignment.

Variables


Constants in Go are values computed at compile time. They can be boolean, numeric, or string. Unlike variables, constants cannot be assigned to at runtime - the compiler enforces this.

<ExamplePair>
<ExampleProse>

`const` declares a single value or a block of values. Constants must be assignable from a literal or a constant expression.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

const Pi = 3.14159
const MaxRetries = 3
const ServiceName = "auth-service"

func main() {
    fmt.Println(Pi, MaxRetries, ServiceName)

    const localTimeout = 30 // constants can be declared inside functions too
    fmt.Println(localTimeout)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`iota` is a compile-time counter that resets to 0 at the start of each `const` block and increments by 1 for each constant. It is the idiomatic way to define enumerations in Go.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Direction int

const (
    North Direction = iota // 0
    East                   // 1
    South                  // 2
    West                   // 3
)

type ByteSize float64

const (
    _           = iota             // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota) // 1024
    MB                             // 1048576
    GB                             // 1073741824
)

func main() {
    fmt.Println(North, East, South, West)
    fmt.Println(KB, MB, GB)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

An *untyped* constant has no explicit type - it adopts a default type at the point of use. A *typed* constant carries its type and will only satisfy type-safe comparisons.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

const untypedMax = 1000        // untyped int constant
const typedMax int32 = 1000    // typed int32 constant

func printInt64(n int64) {
    fmt.Println(n)
}

func main() {
    printInt64(untypedMax) // OK - untyped constant is widened to int64
    // printInt64(typedMax) // compile error: cannot use typedMax (int32) as int64
    _ = typedMax
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Untyped integer constants are assigned a default type (`int`) at the point of use - passing one across a package boundary can produce surprising implicit widening or narrowing depending on the target platform's `int` size (32 vs 64 bits). Typed constants make intent explicit and prevent cross-package confusion. This matters especially for constants used as sizes, capacities, or enum discriminants that flow into serialization formats or database columns where the width is load-bearing.
</InProduction>


const, iota, typed vs untyped constants, and constant expressions evaluated at compile time.

Constants


Go is statically typed - every value has a type known at compile time. The built-in scalar types cover booleans, integers of specific widths, floating-point numbers, and text.

<ExamplePair>
<ExampleProse>

Boolean values are `true` or `false`. Go has no truthiness - non-zero integers and non-nil pointers are not implicitly boolean.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    fmt.Println(true && false) // false
    fmt.Println(true || false) // true
    fmt.Println(!true)         // false
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Go has signed integers (`int8`, `int16`, `int32`, `int64`, and `int`), unsigned variants (`uint8`/`byte`, `uint16`, `uint32`, `uint64`, `uint`), and two floating-point types. `int` and `uint` are platform-width - 64 bits on modern systems.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    fmt.Println(1 + 2)           // 3       (int)
    fmt.Println(7.0 / 3.0)       // 2.3333… (float64)
    fmt.Println(7 / 3)           // 2       (integer division)
    fmt.Println(7 % 3)           // 1

    var b byte = 255             // alias for uint8
    fmt.Println(b)               // 255
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Strings in Go are immutable sequences of bytes (UTF-8 encoded). `rune` is an alias for `int32` and represents a Unicode code point. `byte` is an alias for `uint8` and represents a raw byte.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    s := "Hello, 世界"

    fmt.Println(len(s))           // 13 - byte count, not character count
    fmt.Println([]rune(s))        // slice of Unicode code points

    for i, r := range s {
        fmt.Printf("%d: %c\n", i, r)
    }
    // i is the byte offset; r is the rune at that offset
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`range` over a string yields runes (Unicode code points); `len()` returns bytes. Mixing them causes silent truncation on emoji and CJK input - `s[3]` gives the fourth byte, not the fourth character. In international products, always iterate with `range` when you care about user-visible characters, and use `utf8.RuneCountInString` instead of `len` when you need a character count for display or truncation.
</InProduction>


Go's built-in scalar types - bool, integer variants, float32/float64, byte, rune, and string.