Переменные и оператор присваивания :=

Урок объясняет, что такое переменная, как её объявить и как работает оператор присваивания := в Паскале.

Переменная — это именованная ячейка памяти, в которой программа хранит значение и может его менять по ходу работы.

Зачем нужны переменные

Представьте, что вы решаете задачу в уме: «Прибавь к моему возрасту 5, потом умножь на 2». Чтобы это сделать, вам нужно где-то держать промежуточный результат. У человека это память. У программы — переменные. Переменная — это коробочка с подписанным именем, в которую можно положить число, текст или другое значение, а потом достать его, изменить или использовать в вычислениях.

Без переменных программа была бы беспомощной: она не могла бы запомнить введённые данные, накапливать сумму, считать количество. Любая осмысленная программа постоянно что-то хранит и меняет — а значит, постоянно работает с переменными. Это, без преувеличения, самое важное понятие во всём программировании.

Объявление переменной

В Паскале действует строгое правило: прежде чем пользоваться переменной, её надо объявить — то есть сказать языку её имя и тип хранимых данных. Делается это в разделе var:

var
  age: integer;     // целое число
  height: real;     // дробное число
  letter: char;     // один символ
  name: string;     // строка текста

Запись age: integer читается так: «переменная с именем age будет хранить целые числа». Двоеточие отделяет имя от типа. Несколько переменных одного типа можно перечислить через запятую: var x, y, z: integer;.

Имена переменных придумываете вы, но по правилам: только латинские буквы, цифры и подчёркивание, начинаться с буквы, без пробелов. Хорошее имя говорит о смысле: age лучше, чем a; summa лучше, чем s. Это не требование языка, а уважение к тому, кто будет читать ваш код, — в том числе к вам самим через неделю.

В PascalABC.NET есть приятное упрощение: переменную можно объявить прямо там, где она впервые понадобилась, и даже не указывать тип, если он понятен из значения: var age := 15;. Среда сама догадается, что age — целое. Но в классических учебниках и на экзаменах принят полный способ через раздел var, поэтому им мы и будем пользоваться.

Оператор присваивания :=

Чтобы положить значение в переменную, используют оператор присваивания — двоеточие и равно: :=. Это, пожалуй, самый узнаваемый знак Паскаля.

var
  age: integer;
begin
  age := 15;        // в коробку age кладём 15
  age := age + 1;   // достаём 15, прибавляем 1, кладём обратно 16
  writeln(age);     // напечатает 16
end.

Читать age := 15 нужно как «переменной age присвоить значение 15» или короче «age становится равным 15». Стрелка мысленно идёт справа налево: сначала вычисляется то, что справа, потом результат кладётся в переменную слева.

Самая важная и поначалу странная строка — age := age + 1. С точки зрения математики это бессмыслица (число не может быть равно самому себе плюс один). Но это не уравнение! Это команда: «возьми текущее значение age, прибавь 1, и новый результат снова положи в age». Справа используется старое значение, слева записывается новое. Такой приём — увеличение переменной на единицу — встречается в программах буквально на каждом шагу.

Запустите Python-аналог (в Python присваивание — это просто =):

age = 15
age = age + 1
print(age)

Вывод:

Присваивание — это не равенство

В этом месте спотыкаются почти все новички, поэтому остановимся. В математике знак = означает «равно»: левая и правая части одинаковы, и порядок не важен (2 + 3 = 5 и 5 = 2 + 3 — одно и то же). В Паскале := означает действие: «вычисли справа, положи слева». Порядок важен: слева всегда стоит переменная, справа — то, что в неё кладут.

Поэтому 5 := age — ошибка (нельзя присвоить значение числу 5), а x := y и y := x — совершенно разные команды. Именно чтобы подчеркнуть это отличие от равенства, в Паскале выбрали особый знак :=, а не просто =. Кстати, одинарное = в Паскале тоже есть — оно используется для сравнения (об этом в разделе про условия), но никогда для присваивания. Не путайте их.

Обмен значений двух переменных

Классическая задача: есть две переменные, нужно поменять их значения местами. Кажется, можно так: a := b; b := a;. Но это не работает! После первой команды старое значение a потеряно — затёрто значением b. Нужна третья переменная-«помощник»:

var
  a, b, temp: integer;
begin
  a := 10;
  b := 20;
  temp := a;   // сохраняем a во временной переменной
  a := b;      // в a кладём b
  b := temp;   // в b кладём сохранённое старое a
  writeln('a = ', a, ', b = ', b);
end.

a = 10
b = 20
temp = a
a = b
b = temp
print('a =', a, ', b =', b)

Вывод:

a = 20 , b = 10

Аналогия: чтобы поменять воду в двух стаканах местами, нужен третий пустой стакан. Запомните этот приём — он пригодится, например, в сортировках.

Попробуй сам

Объявите переменную summa типа integer, присвойте ей значение 100, затем прибавьте к ней 50 (через summa := summa + 50), потом удвойте (summa := summa * 2) и выведите результат. Должно получиться 300. Проверьте на запускаемом Python:

summa = 100
summa = summa + 50
summa = summa * 2
print(summa)

Вывод:

Частые ошибки

Использовали = вместо :=. Для присваивания нужен именно :=. Одинарное = — это сравнение, и в строке присваивания среда выдаст ошибку.
Переменная справа без значения. Если справа стоит переменная, которой ещё ничего не присвоили, результат непредсказуем. Сначала задайте значение, потом используйте.
Перепутали стороны. Слева от := может быть только переменная. 10 := x — ошибка.
Обмен без третьей переменной. Прямой обмен a := b; b := a; теряет значение. Нужна переменная-помощник.

Итоги

Переменная — именованная ячейка памяти; в Паскале её надо объявить в разделе var с указанием типа.
Оператор присваивания := вычисляет правую часть и кладёт результат в переменную слева.
x := x + 1 — не равенство, а команда увеличить переменную; справа старое значение, слева новое.
Присваивание := и сравнение = — разные вещи; не путайте их.
Обмен значений двух переменных требует третьей временной переменной.