hexlet-basics · fey · May 29, 2026 · May 29, 2026
diff --git a/modules/30-variables/10-definition/ru/README.md b/modules/30-variables/10-definition/ru/README.md
@@ -1,42 +1,125 @@
-Переменные — один из базовых инструментов программирования. С их помощью программы запоминают и используют данные.
-
-Рассмотрим пример.
+Представьте, что нужно вывести фразу `Father!` два раза:
 
 ```javascript
-let greeting = 'Father!';
-console.log(greeting); // => Father!
+console.log('Father!');
+console.log('Father!');
 ```
 
-Мы **определили переменную** с именем `greeting` и присвоили ей значение `'Father!'`. Теперь вместо строки `'Father!'` можно использовать имя `greeting`.
+Такой способ вполне подойдёт, если фраза встречается всего пару раз. Но что, если она будет использоваться часто, в разных частях программы? Тогда придётся копировать одно и то же выражение снова и снова.
+
+А что будет, если фразу нужно изменить, например заменить _Father!_ на _Mother!_? Придётся искать и исправлять все вхождения вручную. Это неудобно и приводит к ошибкам.
+
+## Переменные
+
+Чтобы не дублировать одну и ту же строку, её можно сохранить в переменной и выводить её содержимое:
 
 ```javascript
-let greeting = 'Father!';
-console.log(greeting); // => Father!
-console.log(greeting); // => Father!
+const greeting = 'Father!';
+
+console.log(greeting);
+console.log(greeting);
+```
+
+Результат:
+
+```text
+Father!
+Father!
+```
+
+**Переменная** представляет собой имя, за которым хранится значение. В нашем примере мы создали переменную с именем `greeting` и записали в неё строку `'Father!'`.
+
+```text
+const greeting = 'Father!';
+
+Переменная       Значение
+┌──────────┐     ┌──────────┐
+│ greeting │ ──→ │ 'Father!'│
+└──────────┘     └──────────┘
 ```
 
-Значение переменной берётся в момент обращения к ней.
+Строчка `const greeting = 'Father!'` читается так: «возьми значение `'Father!'` и присвой его переменной с именем `greeting`». Знак `=` здесь является оператором присваивания, а не обозначением равенства как в математике. Он кладёт значение в переменную.
+
+Когда мы пишем `console.log(greeting)`, движок подставляет вместо имени `greeting` то значение, которое в ней хранится. В результате на экран выводится строка `'Father!'`.
+
+```text
+console.log(greeting)
+            |
+            v
+console.log('Father!')
+```
 
 ## let и const
 
-В JavaScript переменные объявляются двумя способами:
+В JavaScript переменную перед использованием нужно объявить с помощью одного из ключевых слов — `const` или `let`:
+
+- `const` — для значений, которые не будут меняться;
+- `let` — для значений, которые в ходе работы программы могут поменяться.
+
+```javascript
+const greeting = 'Father!'; // меняться не будет
+let score = 0;              // будет меняться по ходу программы
+```
+
+Если не знаете, будет ли значение меняться, используйте `const`. Это хорошая практика: так код проще читать и сложнее случайно испортить данные. К `let` и константам мы ещё вернёмся в отдельных уроках.
 
-- `let` — для значений, которые могут меняться.
-- `const` — для значений, которые не будут меняться (константы).
+## Имена переменных
+
+Имена переменных придумывает сам программист. В JavaScript можно использовать:
+
+- латинские буквы (a-z, A-Z),
+- цифры (но не в начале),
+- символы `_` и `$`.
+
+Примеры допустимых имён: `greeting`, `name1`, `helloWorld`. JavaScript различает строчные и заглавные буквы. Переменные `greeting`, `Greeting` и `GREETING` являются тремя разными переменными.
+
+## Переменные и литералы
+
+В коде важно различать, где мы используем переменную, а где записываем значение напрямую. Это особенно заметно на примере с `console.log()`:
+
+```javascript
+const greeting = 'Mother!';
+console.log(greeting);   // => Mother!
+console.log('greeting'); // => greeting
+```
+
+В первом случае используется **переменная** `greeting`, и программа подставляет её значение. Во втором случае `'greeting'` заключено в кавычки, поэтому это **строковый литерал**, то есть готовое значение, написанное прямо в коде. Несмотря на то, что мы видим слово `greeting` в обоих случаях, с точки зрения движка это абсолютно разные вещи.
+
+Литералы представляют собой данные, записанные явно (например, `'Hello'`, `42`, `3.14`). Идентификаторы являются именами переменных и функций (например, `greeting`, `console`), которые указывают на уже существующие значения или команды.
+
+## Порядок использования
+
+Переменную нужно сначала создать (объявить и присвоить ей значение), а уже потом использовать. Если попытаться обратиться к переменной до её создания, программа выдаст ошибку:
+
+```javascript
+console.log(name); // Ошибка: переменная ещё не определена
+// ReferenceError: Cannot access 'name' before initialization
+const name = 'Alice';
+```
+
+А в правильном порядке всё работает:
 
 ```javascript
-let currentUser = 'Alice';    // может поменяться позже
-const maxAttempts = 3;        // никогда не изменится
+const name = 'Alice';
+console.log(name); // => Alice
 ```
 
-Если не знаете, будет ли значение меняться — используйте `const`. Это хорошая практика.
+## Несколько переменных в программе
+
+В одной программе можно создать сколько угодно переменных. Каждая хранит свои данные и не мешает другим:
 
-## Правила именования
+```javascript
+const greeting1 = 'Father!';
+console.log(greeting1);
+console.log(greeting1);
+
+const greeting2 = 'Mother!';
+console.log(greeting2);
+console.log(greeting2);
+```
 
-Имена переменных в JavaScript:
+Как понять, когда нужно несколько переменных? Количество переменных зависит от логики программы. Эта тема подробно раскрывается позже, когда мы столкнёмся с функциями и условными конструкциями.
 
-- Могут содержать буквы, цифры, `_` и `$`.
-- Не могут начинаться с цифры.
-- Чувствительны к регистру: `greeting` и `Greeting` — разные переменные.
+## Где создавать переменные
 
-Имена по стилю записываются в lowerCamelCase: `firstName`, `maxLoginAttempts`.
+Программисты стараются создавать переменные ближе к месту, где они используются. Это делает код более читаемым. Особенно важно это в больших программах, где переменных может быть десятки и сотни тысяч.
diff --git a/modules/30-variables/11-change/ru/README.md b/modules/30-variables/11-change/ru/README.md
@@ -1,30 +1,49 @@
-Переменная потому и называется переменной, что её значение можно **изменить**.
+Само слово «переменная» подсказывает, что её значение может меняться. Это одна из главных причин, почему переменные вообще существуют.
+
+Вот простой пример:
 
 ```javascript
+// greeting переводится как «приветствие»
 let greeting = 'Father!';
 console.log(greeting); // => Father!
 
 greeting = 'Mother!';
 console.log(greeting); // => Mother!
 ```
 
-Обратите внимание: ключевое слово `let` пишется только при **первом** объявлении переменной. При повторном присваивании `let` уже не нужен.
+Здесь мы сначала записали в переменную одну строку (_Father!_), потом другую (_Mother!_). Имя переменной не изменилось, но значение внутри стало другим.
+
+```text
+До:    greeting ──→ 'Father!'
+                     ╳
+После: greeting ──→ 'Mother!'
+```
+
+Обратите внимание: ключевое слово `let` пишется только при **первом** объявлении переменной. При повторном присваивании `let` уже не нужен — переменная уже существует, мы лишь меняем её значение.
 
-## Зачем это нужно?
+## Зачем вообще менять значение?
 
-Переменные меняются в самых разных ситуациях:
+В реальных программах переменные меняются постоянно. Вот несколько причин:
 
-- Пользователь обновляет своё имя в профиле.
-- Игровой персонаж теряет или находит жизни.
-- В процессе вычислений накапливается промежуточный результат.
+- Программа реагирует на действия пользователя. Например, пока вы вводите данные в форму на сайте, переменные, которые эти данные содержат, в этот момент постоянно обновляются.
+- Промежуточные результаты. Часто данные проходят через серию преобразований, и на каждом этапе переменная обновляется новым значением. Подобный механизм даже есть в калькуляторах, когда промежуточные значения сохраняются с помощью клавиш `m+` или `m-`.
+- Хранение состояния. Если вы пишете игру, то положение персонажа, его здоровье, счёт и текущий уровень являются переменными, которые постоянно меняются.
 
 ## const не меняется
 
-Если переменная объявлена через `const`, её нельзя переприсвоить.
+Не каждую переменную можно переприсвоить. Если переменная объявлена через `const`, её значение менять нельзя:
 
 ```javascript
 const greeting = 'Father!';
 greeting = 'Mother!'; // TypeError: Assignment to constant variable.
 ```
 
-Поэтому для значений, которые будут меняться, используйте `let`.
+Поэтому для значений, которые будут меняться, используют `let`, а для постоянных — `const`. Так работает большинство современных языков программирования: значение, которое не должно меняться, помечают отдельно.
+
+## Почему это важно
+
+Переменные представляют собой гибкий способ хранить данные, которые могут изменяться в процессе выполнения программы. Благодаря этому можно писать программы, которые ведут себя по-разному в зависимости от условий, действий пользователя или результатов вычислений.
+
+Но у гибкости есть и обратная сторона. Иногда сложно сразу понять, что именно записано в переменную в тот или иной момент времени. Разработчику приходится отслеживать, где и как она изменилась, особенно если код длинный.
+
+Именно это делают во время отладки: пытаются разобраться, почему программа работает иначе, чем задумано. Проверяют значения переменных, отслеживают порядок выполнения кода, ищут, где что-то пошло не так.
diff --git a/modules/30-variables/13-variables-naming/ru/README.md b/modules/30-variables/13-variables-naming/ru/README.md
@@ -1,35 +1,38 @@
-Компьютеру всё равно, как называются переменные. Но код читают люди — и для них это имеет огромное значение.
-
-Посмотрите на два примера.
+Представьте, что у нас есть такая программа:
 
 ```javascript
-const x = 'John';
-const abcd = 30;
+const x = 'Father!';
+console.log(x);
 ```
 
-vs
+С технической точки зрения всё работает. Мы уже видели похожие примеры, но здесь используется переменная с названием `x`. Плохие имена мешают читать и понимать код. Вот несколько примеров неудачных переменных:
 
 ```javascript
-const firstName = 'John';
-const age = 30;
+const a = 'John';
+const n = 42;
+const ddr = 'New York';
 ```
 
-Первый вариант написан для компьютера, второй — для человека.
+Что это за переменные? Что в них хранится? Чтобы это понять, нужно читать весь остальной код и догадываться по контексту.
+
+Компьютеру всё равно, как называется переменная. Для него `x`, `abc`, `message` или `elephantInTheRoom` являются просто метками для хранения данных. Людям важно другое. Программисты читают код гораздо чаще, чем пишут. Поэтому имена переменных являются важной частью общения через код.
 
-## Требования к именам
+## Хорошие примеры
 
-- Имя должно отражать содержимое, а не тип: `userName` лучше, чем `userString`.
-- Используйте английский язык: `firstName`, а не `имя`.
-- Не бойтесь длинных имён: `maxLoginAttempts` лучше, чем `mla`.
+```javascript
+const userName = 'Arya Stark';
+const unpaidOrdersCount = 3;
+const maxAttempts = 5;
+```
 
-## Сложная задача
+Хорошее имя переменной помогает понять, что делает программа, не вчитываясь в каждую строчку. Особенно важно давать такие имена, смысл которых понятен без контекста, без необходимости читать весь код вокруг.
 
-Как назвать переменную, которая хранит количество братьев и сестёр короля?
+Вот несколько советов:
 
-Какой из вариантов вы бы выбрали?
+- Используйте английский язык. Это международный стандарт. Лучше писать `ordersCount` вместо `kolvoZakazov`. Если с английским пока сложно, используйте переводчик, это нормально. Со временем станет проще.
+- Старайтесь, чтобы имя отражало смысл переменной. Пусть оно будет чуть длиннее, но понятное.
+- Не бойтесь тратить время на подбор хорошего названия. Это инвестиция в читаемость и поддержку кода.
 
-- `x` — непонятно ничего
-- `count` — count чего?
-- `siblingsCount` — понятно и точно ✓
+Среди программистов даже есть шутка: «Одними из самых трудных задач в программировании являются кэширование и придумывание имён переменным». Иногда придумать подходящее имя действительно сложно. Вот пример: как бы вы назвали переменную, в которой хранится количество неоплаченных заказов от клиентов с задолженностью за предыдущий квартал?
 
-Именование — одна из самых сложных задач в программировании. Со временем хорошие имена приходят сами собой.
+А теперь небольшое упражнение: придумайте название для переменной, в которой будет храниться «количество братьев и сестёр короля». Запишите его в блокноте или отправьте себе на почту. Только название, без объяснений. Мы вернёмся к этому заданию через несколько уроков.