Variables & Constants

Introduction

Variables and constants are how a program stores and names the data it works with. Go gives you two ways to declare variables — the explicit `var` keyword and the shorthand `:=` operator — plus a distinctive feature called `iota` for cleanly generating related constant values.

This lesson covers both declaration styles, Go's "zero value" guarantee, and how constants (including iota) work.

Declaring Variables with var

The `var` keyword declares a variable with an explicit type, an inferred type from an initial value, or both.

package main

import "fmt"

func main() {
	var age int = 25          // explicit type and value
	var name = "Alice"        // type inferred from the value (string)
	var isActive bool         // no value — gets the zero value (false)

	fmt.Println(age, name, isActive)
}

You can also declare several variables in one `var` block, which is common at the top of a file for package-level variables.

var (
	appName    = "PrograMinds"
	maxRetries = 3
	debugMode  = false
)

Short Declaration with :=

Inside functions, the `:=` short variable declaration is the most common way to declare and initialize a variable — it infers the type automatically and needs no `var` keyword.

package main

import "fmt"

func main() {
	name := "Bob"
	score := 92
	passed := score >= 60

	fmt.Println(name, score, passed)
}

Zero Values

Unlike many languages where an uninitialized variable is undefined or null, every Go variable declared without an explicit value is automatically set to its type's "zero value" — a well-defined default. This eliminates an entire category of "uninitialized variable" bugs.

package main

import "fmt"

func main() {
	var count int
	var label string
	var found bool

	fmt.Println(count, label == "", found)
}

var vs := — Which to Use

Constants with const

Constants are declared with `const` and must be assigned a value that can be computed at compile time — you cannot assign the result of a function call, for example. Once declared, a constant's value can never change.

package main

import "fmt"

const Pi = 3.14159
const AppName = "PrograMinds"

func main() {
	const maxUsers = 100 // constants can also be local
	fmt.Println(Pi, AppName, maxUsers)
}

Generating Constants with iota

`iota` is a special Go identifier used inside a `const` block that automatically generates a sequence of related integer constants, starting at 0 and incrementing by 1 for each new line. It's commonly used to build enum-like sets of named constants.

package main

import "fmt"

type Weekday int

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

func main() {
	fmt.Println(Sunday, Wednesday, Saturday)
}

Each subsequent line in the `const` block automatically repeats the same expression (`Weekday = iota`) with `iota` incremented, so you only need to write it once on the first line.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You now know both ways to declare variables in Go, what zero values guarantee, and how to define constants — including using iota to generate related values automatically. Next, you'll take a closer look at Go's built-in data types.