Part 2. Language BasicsLesson 03# go# basics# variables

Variables and constants

var and :=, zero values, const and iota, swapping values

Цели главы

  • Объявлять переменные тремя способами и знать, где какой допустим.
  • Различать создание (:=) и изменение (=).
  • Знать нулевые значения и правила именования.
  • Объявлять константы, группы констант и перечисления через iota.

Переменная — имя для значения

В реальном приложении данные постоянно меняются: обновляется рейтинг, приходят и уходят подписчики, растут цены. Переменная — это имя, привязанное к значению. Как ценник в магазине: надпись «молоко» остаётся, а цена на нём завтра может стать другой. Без переменных пришлось бы помнить, что 8.6 — это рейтинг, а 2014 — год; с ними пишем rating и year, и всё понятно.

Три способа объявить переменную

go
package main

import "fmt"

func main() {
    var rating float64 = 8.6   // полная форма: имя, тип, значение
    var title = "Интерстеллар" // тип выводится из значения справа
    year := 2014               // короткая форма — основная в реальном коде
    watched := true

    fmt.Println(title, year, rating, watched)
}
stdout // вывод программы
Интерстеллар 2014 8.6 true
Форма Что указываем Где можно Когда использовать
var rating float64 = 8.6 имя, тип и значение везде редко; когда важно явно показать тип
var rating = 8.6 имя и значение, тип выведет Go везде на уровне пакета, вне функций
rating := 8.6 имя и значение только внутри функций в 90% случаев

Оператор := делает три вещи сразу: создаёт переменную, определяет тип по значению и присваивает значение. В примере встретились четыре базовых типа: float64 — дробное число, string — строка, int — целое, bool — логическое true/false. Подробно о типах — в 04 — Типы данных и преобразования.

Объявил — используй

Неиспользованная локальная переменная — ошибка компиляции, а не предупреждение. Если значение не нужно, его отбрасывают пустым идентификатором _.

go
func main() {
    rating := 8.6 // declared and not used: rating
}

Поэтому в примерах каждая переменная где-то выводится через fmt.Println.

Изменение значения

Переменную потому и называют переменной, что её значение можно менять. Для изменения пишут = без двоеточия:

go
package main

import "fmt"

func main() {
    rating := 8.3
    rating = 8.2  // изменение — просто =
    rating += 0.5 // то же, что rating = rating + 0.5
    fmt.Printf("%.1f\n", rating)

    var subscribers int // объявили без значения — получили 0
    subscribers++
    fmt.Println(subscribers)
}
stdout // вывод программы
8.7
1
  • Повторное rating := … для уже объявленной переменной — ошибка no new variables on left side of :=.
  • var имя тип без значения нужен, когда значение появится позже. Go никогда не оставляет в переменной мусор: она получает нулевое значение (zero value) — 0 для чисел, "" для строк, false для bool. Полная таблица — в 04 — Типы данных и преобразования → Нулевые значения.

Константы

Значение, которое не должно меняться никогда, объявляют через const:

go
const maxRating = 10.0

maxRating = 15.0 // cannot assign to maxRating (neither addressable nor a map index expression)

Константы используют для настроек, математических значений вроде числа π и статусов. Их можно группировать в скобках, и, в отличие от переменных, неиспользованная константа — не ошибка.

go
package main

import "fmt"

const maxRating = 10.0

const (
    defaultPlan = "Basic"
    trialDays   = 14
)

const (
    PlanFree    = iota // 0
    PlanBasic          // 1
    PlanPremium        // 2
)

func main() {
    fmt.Println(maxRating, defaultPlan, trialDays)
    fmt.Println(PlanFree, PlanBasic, PlanPremium)
}
stdout // вывод программы
10 Basic 14
0 1 2

Несколько переменных сразу и обмен значениями

Go объявляет и присваивает несколько переменных в одну строку, а значит, умеет менять значения местами без временной переменной — во многих языках так нельзя.

go
package main

import "fmt"

func main() {
    width, height, fps := 1920, 1080, 60
    fmt.Println(width, height, fps)

    left, right := "left", "right"
    left, right = right, left // обмен без временной переменной
    fmt.Println(left, right)
}
stdout // вывод программы
1920 1080 60
right left

Правила именования

  • Можно буквы, цифры и подчёркивание; начинать — с буквы или _.
  • Нельзя пробелы и дефисы, нельзя начинать с цифры.
  • := работает только внутри функций, снаружи — только var; иначе syntax error: non-declaration statement outside function body.
  • Неиспользуемая локальная переменная — ошибка; ненужное значение отбрасывай через _.
  • Регистр различается: Title, title и TITLE — три разные переменные.

Практика

Домашнее задание: калькулятор подписки GoFlix

  • Создай константы для базовой цены и названия тарифа.
  • Создай переменные всеми тремя способами: var months int = 12, var discount = 15.0 и total := ….
  • Посчитай итоговую стоимость с учётом скидки и выведи красивый чек через Println и Printf.

Результат должен выглядеть так:

text
===== ЧЕК GoFlix =====
Тариф: Premium
Месяцев: 12
Базовая цена: 999.00 руб/мес
Скидка: 15%
Итого: 10189.80 руб.
решениеЭталонное решение
go
package main

import "fmt"

const (
    planName  = "Premium"
    basePrice = 999.0 // руб/мес
)

func main() {
    var months int = 12
    var discount = 15.0
    total := basePrice * float64(months) * (1 - discount/100)

    fmt.Println("===== ЧЕК GoFlix =====")
    fmt.Println("Тариф:", planName)
    fmt.Println("Месяцев:", months)
    fmt.Printf("Базовая цена: %.2f руб/мес\n", basePrice)
    fmt.Printf("Скидка: %.0f%%\n", discount)
    fmt.Printf("Итого: %.2f руб.\n", total)
}
stdout // вывод программы
===== ЧЕК GoFlix =====
Тариф: Premium
Месяцев: 12
Базовая цена: 999.00 руб/мес
Скидка: 15%
Итого: 10189.80 руб.

Тренировка: предскажи вывод

go
package main

import "fmt"

func main() {
    a, b := 1, 2
    a, b = b, a+b
    fmt.Println(a, b)
}
самопроверкаОтвет
text
2 3

Правая часть вычисляется целиком до присваивания: сначала берутся значения b (2) и a+b (3), и только потом они записываются в a и b.

Проверь себя

вопросНазови три способа объявить переменную. Какой работает только внутри функций?

var x float64 = 8.6, var x = 8.6 и x := 8.6. Только внутри функций работает :=.

вопросЧем x := 5 отличается от x = 5?

:= создаёт новую переменную и выводит её тип. = меняет значение уже существующей.

вопросЧто будет, если объявить локальную переменную и не использовать её?

Ошибка компиляции declared and not used. Ненужное значение отбрасывают через _.

вопросКакое значение у var count int и var name string?

Нулевые значения: 0 и пустая строка "".

вопросМожно ли объявить константу и не использовать её?

Да. Неиспользуемая константа — не ошибка, в отличие от переменной.

вопросКак поменять значения двух переменных местами?

a, b = b, a — правая часть вычисляется до присваивания, временная переменная не нужна.


Ключевые выводы

  • ✍️ Три способа объявить переменную; := — основной, но только внутри функций.
  • 🔁 Создание — :=, изменение — =; повторный := без новых переменных — ошибка.
  • 0️⃣ Переменная без значения получает нулевое значение своего типа, мусора не бывает.
  • 🚫 Неиспользованная локальная переменная — ошибка компиляции.
  • 🔒 const нельзя изменить; группы констант с iota заменяют перечисления.

Chapter goals

  • Declare variables three ways and know where each one is allowed.
  • Tell creation (:=) apart from assignment (=).
  • Know zero values and naming rules.
  • Declare constants, constant groups, and enumerations with iota.

A variable is a name for a value

In a real application data changes all the time: ratings update, subscribers come and go, prices grow. A variable is a name bound to a value. Like a price tag in a store: the label "milk" stays, but the price on it can be different tomorrow. Without variables you'd have to remember that 8.6 is the rating and 2014 is the year; with them you write rating and year, and everything is clear.

Three ways to declare a variable

go
package main

import "fmt"

func main() {
    var rating float64 = 8.6   // full form: name, type, value
    var title = "Interstellar" // the type is inferred from the value on the right
    year := 2014               // short form — the workhorse of real code
    watched := true

    fmt.Println(title, year, rating, watched)
}
stdout // program output
Interstellar 2014 8.6 true
Form What you specify Where it's allowed When to use it
var rating float64 = 8.6 name, type, and value anywhere rarely; when the type matters explicitly
var rating = 8.6 name and value, Go infers the type anywhere at package level, outside functions
rating := 8.6 name and value inside functions only in 90% of cases

The := operator does three things at once: creates the variable, determines the type from the value, and assigns the value. The example used four basic types: float64 — a fractional number, string — a string, int — an integer, bool — the logical true/false. Details on types — in 04 — Data types and conversions.

Declared it — use it

An unused local variable is a compile error, not a warning. If you don't need the value, discard it with the blank identifier _.

go
func main() {
    rating := 8.6 // declared and not used: rating
}

That's why in the examples every variable gets printed somewhere through fmt.Println.

Changing a value

A variable is called a variable precisely because its value can change. To change it, write = without the colon:

go
package main

import "fmt"

func main() {
    rating := 8.3
    rating = 8.2  // assignment — just =
    rating += 0.5 // same as rating = rating + 0.5
    fmt.Printf("%.1f\n", rating)

    var subscribers int // declared without a value — got 0
    subscribers++
    fmt.Println(subscribers)
}
stdout // program output
8.7
1
  • A repeated rating := … for an already declared variable is the no new variables on left side of := error.
  • var name type without a value is for when the value appears later. Go never leaves garbage in a variable: it gets the zero value — 0 for numbers, "" for strings, false for bool. The full table — in 04 — Data types and conversions → Zero values.

Constants

A value that must never change is declared with const:

go
const maxRating = 10.0

maxRating = 15.0 // cannot assign to maxRating (neither addressable nor a map index expression)

Constants are used for settings, mathematical values like π, and statuses. They can be grouped in parentheses, and unlike variables, an unused constant is not an error.

go
package main

import "fmt"

const maxRating = 10.0

const (
    defaultPlan = "Basic"
    trialDays   = 14
)

const (
    PlanFree    = iota // 0
    PlanBasic          // 1
    PlanPremium        // 2
)

func main() {
    fmt.Println(maxRating, defaultPlan, trialDays)
    fmt.Println(PlanFree, PlanBasic, PlanPremium)
}
stdout // program output
10 Basic 14
0 1 2

Several variables at once and swapping

Go declares and assigns several variables in one line, which also means it can swap values without a temporary variable — many languages can't do that.

go
package main

import "fmt"

func main() {
    width, height, fps := 1920, 1080, 60
    fmt.Println(width, height, fps)

    left, right := "left", "right"
    left, right = right, left // swap without a temporary variable
    fmt.Println(left, right)
}
stdout // program output
1920 1080 60
right left

Naming rules

  • Letters, digits, and underscores are allowed; the name must start with a letter or _.
  • No spaces or hyphens, and it can't start with a digit.
  • := works only inside functions; outside it's var only — otherwise syntax error: non-declaration statement outside function body.
  • An unused local variable is an error; discard unneeded values with _.
  • Case matters: Title, title, and TITLE are three different variables.

Practice

Homework: GoFlix subscription calculator

  • Create constants for the base price and the plan name.
  • Create variables all three ways: var months int = 12, var discount = 15.0, and total := ….
  • Calculate the final price with the discount and print a nice receipt with Println and Printf.

The result should look like this:

text
===== GoFlix RECEIPT =====
Plan: Premium
Months: 12
Base price: 999.00 RUB/mo
Discount: 15%
Total: 10189.80 RUB.
solution
go
package main

import "fmt"

const (
    planName  = "Premium"
    basePrice = 999.0 // RUB/mo
)

func main() {
    var months int = 12
    var discount = 15.0
    total := basePrice * float64(months) * (1 - discount/100)

    fmt.Println("===== GoFlix RECEIPT =====")
    fmt.Println("Plan:", planName)
    fmt.Println("Months:", months)
    fmt.Printf("Base price: %.2f RUB/mo\n", basePrice)
    fmt.Printf("Discount: %.0f%%\n", discount)
    fmt.Printf("Total: %.2f RUB.\n", total)
}
stdout // program output
===== GoFlix RECEIPT =====
Plan: Premium
Months: 12
Base price: 999.00 RUB/mo
Discount: 15%
Total: 10189.80 RUB.

Exercise: predict the output

go
package main

import "fmt"

func main() {
    a, b := 1, 2
    a, b = b, a+b
    fmt.Println(a, b)
}
self-check
text
2 3

The right-hand side is evaluated in full before the assignment: first the values of b (2) and a+b (3) are taken, and only then written into a and b.

Check yourself

questionName three ways to declare a variable. Which one works only inside functions?

var x float64 = 8.6, var x = 8.6, and x := 8.6. Only := works exclusively inside functions.

questionHow is x := 5 different from x = 5?

:= creates a new variable and infers its type. = changes the value of an existing one.

questionWhat happens if you declare a local variable and don't use it?

The declared and not used compile error. Unneeded values are discarded with _.

questionWhat's in var count int and var name string?

Zero values: 0 and the empty string "".

questionCan you declare a constant and not use it?

Yes. An unused constant is not an error, unlike a variable.

questionHow do you swap the values of two variables?

a, b = b, a — the right-hand side is evaluated before the assignment, no temporary variable needed.


Key takeaways

  • ✍️ Three ways to declare a variable; := is the workhorse, but only inside functions.
  • 🔁 Creation is :=, assignment is =; a repeated := with no new variables is an error.
  • 0️⃣ A variable without a value gets its type's zero value — there's no garbage.
  • 🚫 An unused local variable is a compile error.
  • 🔒 const can't be changed; constant groups with iota replace enumerations.
// related topics and cheatsheets