Variables

By the end of this lesson you'll be able to store text, numbers, and true/false values in Go, declare them three different ways, convert safely between types, and print them in clean output — the foundation of every Go program you'll write.

Part of the free Go course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

📊 The Core Data Types

Type

Holds

Example

Zero value

int

Whole numbers

age := 25

0

float64

Decimal numbers

h := 1.75

string

Text

n := "Al"

"" (empty)

bool

true / false

ok := true

false

Strings use "double quotes" . Go also has byte , rune , and sized numbers like int64 , but the four above carry you through almost everything early on. Note Go writes true / false in lowercase .

1️⃣ Declaring Variables

Go gives you three ways to make a variable. var name type = value is the explicit form. You can drop the type and let Go infer it from the value. And inside a function the short declaration := does both at once — it's the form you'll reach for most. Use descriptive names like firstName or totalPrice ; code is read far more often than written. Read this worked example, run it, then you'll write your own.

Your turn. The program below is almost complete — fill in the three blanks marked ___ using the hints, then run it and check your output.

2️⃣ Zero Values & Multiple Assignment

In some languages a variable with no value is "undefined" and reading it is a bug. Go is safer: every type has a zero value it falls back to — 0 for numbers, "" for strings, false for bools. You can also declare several variables at once, which makes the classic two-line swap a single, clean line.

3️⃣ Constants with const

A constant is a value that must never change after it's set, and the Go compiler enforces that for you. Use const for fixed facts like a tax rate or a maximum limit — it documents your intent and stops accidental edits. Constants can live at package level (outside any function) or inside one. Note constants use = , never := .

4️⃣ Type Conversion

Go is statically typed and — unlike JavaScript or Python — has no implicit conversion . You can't add an int to a float64 directly; you convert one first. The syntax is the target type as a function: float64(x) , int(x) . Converting between numbers and text is different — that needs the strconv package ( strconv.Itoa for int→string, strconv.Atoi for string→int).

Now you try. Input from a user always arrives as string text, so before you can do maths you must convert it. Fill in the two blanks:

Pro Tips

• 💡 Reach for := for local variables and var for package-level values or when you want an explicit type.
• 💡 Floats are float64 by default — prefer it over float32 unless you have a specific reason.
• 💡 Always check the error from strconv.Atoi — text from a user might not be a number. Discard it with _ only when you're certain.
• 💡 Name things well: totalPrice tells a story; tp or x doesn't.

Common Errors (and the fix)

• "declared and not used" — in Go an unused local variable is a compile error , not a warning. Use the variable, remove it, or assign it to _ (the blank identifier) to discard it on purpose.
• "non-declaration statement outside function body" — := only works inside a function. At package level you must use var or const .
• "invalid operation: mismatched types int and float64" — Go never mixes types implicitly. Convert one side first: float64(myInt) + myFloat .
• "no new variables on left side of :=" — you used := on a name that already exists. Use = to reassign an existing variable.
• "cannot assign to MaxUsers (neither addressable nor a map index expression)" — you tried to change a const . Constants can't be reassigned; use a var if the value needs to change.

📋 Quick Reference

Task

Go Syntax

Result

Short declare

name := "Alice"

Explicit type

var age int = 25

Constant

const Pi = 3.14

never changes

int → float64

float64(7)

7.0

float64 → int

int(3.9)

3 (truncates)

int → string

strconv.Itoa(42)

"42"

string → int

strconv.Atoi("42")

42, nil

Zero values: int → 0, float64 → 0, string → "" (empty), bool → false.

Frequently Asked Questions

Use := for the everyday case — a local variable inside a function whose type is obvious from its value. Use var when you need a package-level variable, want to state the type explicitly, or want a variable to start at its zero value with no initial value.

Q: Why won't my program compile because of an "unused" variable?

Go treats an unused local variable as a real error to keep code clean. Either use it, delete it, or assign it to the blank identifier _ if you genuinely need to ignore a value (common with the error from strconv.Atoi ).

Go never converts number types behind your back, because silent conversions hide bugs. Convert one side explicitly: float64(myInt) + myFloat . This is intentional strictness, not a missing feature.

Q: What's the difference between const and var ?

A var can be reassigned later; a const is fixed at compile time and can never change. Use const for fixed facts (a tax rate, a maximum) so the compiler stops accidental edits.

Mini-Challenge: Profile Card

No blanks this time — just a brief and an outline to keep you on track. Declare the variables yourself, print a tidy profile, and check your output against the example in the comments. This is exactly the kind of small program real apps are made of.

🎉 Lesson Complete!

• ✅ Three ways to declare: var name type = value , type inference, and :=
• ✅ Core types: int , float64 , string , bool (with true / false lowercase)
• ✅ Every type has a zero value ; multiple assignment lets you swap in one line
• ✅ const locks a value the compiler won't let you change
• ✅ Go has no implicit conversion — use int(x) , float64(x) , and strconv
• ✅ An unused local variable is a compile error , and := only works inside functions
• ✅ Next lesson: Functions and Methods — package up logic you can reuse

Practice quiz

Continue this course

• Previous: Introduction to Go
• Next: Functions and Methods