Merge pull request #813 from hexlet-basics/update-33-data-types-from-python

feat(33-data-types): полный перенос теории из Python и адаптация под JS

Author: fey

modules/33-data-types/10-primitive-data-types/index.js

@@ -1 +1,13 @@
-console.log(-0.304);
+const currentYear = 2026;
+
+// BEGIN
+const name = 'Anna';
+const birthYear = 1994;
+const age = currentYear - birthYear;
+const rating = 4.7;
+
+console.log(`Name: ${name}`);
+console.log(`Birth year: ${birthYear}`);
+console.log(`Age: ${age}`);
+console.log(`Rating: ${rating}`);
+// END

modules/33-data-types/10-primitive-data-types/ru/EXERCISE.md

@@ -1 +1,20 @@
-Выведите на экран число `-0.304`.
+В программе уже задан текущий год:
+
+```javascript
+const currentYear = 2026;
+```
+
+Напишите программу, которая выводит данные профиля в таком формате:
+
+```text
+Name: Anna
+Birth year: 1994
+Age: 32
+Rating: 4.7
+```
+
+Для этого:
+
+- создайте переменную с годом рождения;
+- вычислите возраст на основе текущего года;
+- выведите данные на экран с подписями слева.

modules/33-data-types/10-primitive-data-types/ru/README.md

@@ -1,34 +1,75 @@
-Все значения в программировании имеют **тип**. Тип определяет, какие операции можно выполнять с данными.
+Программы работают с разной информацией: текстом, числами, датами, логическими значениями. У каждого значения в программе есть тип.
 
-## Примитивные типы в JavaScript
+Например:
 
-JavaScript имеет следующие примитивные типы:
+- `'Hello, World!'` является строкой (`string`);
+- `7`, `-198`, `0`, `3.14` являются числами (`number`);
+- `true` и `false` являются логическими значениями (`boolean`).
 
-| Тип | Примеры | Назначение |
-|-----|---------|------------|
-| `number` | `42`, `3.14`, `-7` | Числа (целые и дробные) |
-| `string` | `'hello'`, `"world"` | Текст |
-| `boolean` | `true`, `false` | Логические значения |
-| `null` | `null` | Намеренное отсутствие значения |
-| `undefined` | `undefined` | Неинициализированная переменная |
+## Что такое тип данных?
+
+Тип данных определяет:
+
+- какие значения к нему относятся;
+- какие операции с ним можно делать.
+
+Например, числа можно складывать, делить и умножать. А строки складываются по-другому — при помощи конкатенации. Умножать строку на строку бессмысленно:
 
 ```javascript
-const age = 25;            // number
-const name = 'Alice';      // string
-const isActive = true;     // boolean
-const nothing = null;      // null
-let unset;                 // undefined
+// Бессмыслица: 'мама' * 'блокнот'
 ```
 
-## Зачем нужны типы?
+## Числа и строки относятся к разным типам
 
-Тип влияет на поведение операций. Например, `+` для чисел — это сложение, а для строк — конкатенация:
+Пример вывода числа:
 
 ```javascript
-console.log(1 + 2);       // => 3
-console.log('1' + '2');   // => '12'
+console.log(5);  // => 5
+console.log(-5); // => -5
 ```
 
+Пример вывода строки:
+
+```javascript
+console.log('5');  // => 5
+console.log('-5'); // => -5
+```
+
+На экране результат выглядит одинаково, но внутри программы это совершенно разные вещи:
+
+| Значение | Тип данных            |
+|----------|-----------------------|
+| `5`      | `number` (число)      |
+| `'5'`    | `string` (строка)     |
+
+## Числа в JavaScript
+
+Во многих языках целые и дробные числа — это разные типы (например, в Python это `int` и `float`). В JavaScript такого деления нет: и целые, и дробные числа относятся к одному типу — `number`.
+
+```javascript
+console.log(10.234);     // => 10.234
+console.log(-0.4);       // => -0.4
+
+console.log(3.5 + 1.2);  // => 4.7
+console.log(5 / 2);      // => 2.5
+console.log(2.75 - 0.5); // => 2.25
+```
+
+## Примитивные типы
+
+Типы вроде `string`, `number`, `boolean` называются примитивными — они встроены прямо в язык.
+
+```text
+Примитивные типы JavaScript
+├── number    : числа (целые и дробные)  (7, -3, 3.14)
+├── string    : строки                   ('hello')
+├── boolean   : логический тип           (true, false)
+├── null      : намеренное отсутствие значения
+└── undefined : значение не задано
+```
+
+Кроме строк и чисел, в JavaScript есть логический тип `boolean` со значениями `true` и `false`, а также специальные значения `null` и `undefined`. Подробнее мы столкнёмся с ними в будущем.
+
 ## Как узнать тип значения
 
 Оператор `typeof` возвращает тип в виде строки:
@@ -40,3 +81,5 @@ console.log(typeof true);      // => 'boolean'
 console.log(typeof undefined); // => 'undefined'
 console.log(typeof null);      // => 'object'  (историческая ошибка JS)
 ```
+
+Существуют и составные типы — массивы, объекты и другие. С ними мы познакомимся позже. Более того, в JavaScript можно создавать и свои собственные типы (например, классы), но для начала важно хорошо разобраться с примитивами.

modules/33-data-types/10-primitive-data-types/test.js

@@ -8,5 +8,5 @@ test('hello world', async () => {
 
   const firstArg = consoleLogSpy.mock.calls.join('\n');
 
-  expect(firstArg).toBe('-0.304');
+  expect(firstArg).toBe('Name: Anna\nBirth year: 1994\nAge: 32\nRating: 4.7');
 });

modules/33-data-types/47-data-types-immutability/ru/README.md

@@ -1,35 +1,65 @@
-**Примитивные типы** в JavaScript неизменяемы (immutable). Это значит, что после создания строку нельзя изменить — ни поменять символ, ни добавить новый.
+Представим, что у нас есть строка, и мы хотим заменить в ней один символ, например первую букву имени:
 
 ```javascript
 let greeting = 'Hello';
-
-// Попытка изменить первый символ — ничего не произойдёт
 greeting[0] = 'J';
 console.log(greeting); // => Hello (не изменилось!)
 ```
 
-## Что можно сделать
+В отличие от некоторых языков, где такая попытка приводит к ошибке, в JavaScript присваивание по индексу просто **тихо игнорируется**: строка не меняется (а в строгом режиме это вызовет ошибку `TypeError`). Причина одна: строки в JavaScript нельзя изменять по частям. После создания они становятся неизменяемыми (или, как говорят программисты, иммутабельными).
+
+## Почему строки неизменяемые?
+
+Примитивные типы (строки, числа, логические значения) в JavaScript менять нельзя. Это даёт важные преимущества:
+
+- Безопасность: значения не изменятся случайно.
+- Производительность: с неизменяемыми значениями проще работать внутри движка.
+- Предсказуемость: меньше неожиданных эффектов при передаче данных в функции.
+
+## А как тогда «изменить» строку?
+
+Если нужно «изменить» строку, создают новую на основе старой и сохраняют её в ту же переменную. Например, заменим первую букву:
+
+```javascript
+const word = 'hello';
+const fixed = 'H' + word.slice(1);
+console.log(fixed); // => Hello
+```
+
+```text
+word = 'hello'
+
+word[0] = 'H'  →  ничего не происходит, строки неизменяемы
 
-Переприсвоить переменную целиком — это работает:
+'H' + word.slice(1)
+└────────┬────────┘
+     'Hello'        ←  создана новая строка
+```
+
+Переприсвоить переменную целиком тоже можно — но это создаёт **новую** строку, а не меняет старую:
 
 ```javascript
 let greeting = 'Hello';
 greeting = 'Jello';
 console.log(greeting); // => Jello
 ```
 
-Но это создаёт **новую строку**, а не изменяет старую.
-
-## Зачем это знать?
+## Новая переменная или та же?
 
-Если вам нужно «изменить» строку, нужно создавать новую на основе старой. Например, заменить первый символ:
+Переиспользовать переменную стоит только тогда, когда речь идёт об одной и той же сущности. Если это уже другие данные, лучше завести отдельную переменную:
 
 ```javascript
-const word = 'hello';
-const fixed = 'H' + word.slice(1);
-console.log(fixed); // => Hello
+// Одна и та же строка, просто обновляем
+let name = 'Alexander';
+name = 'Blexander';
+
+// Разные сущности — лучше разные переменные
+const firstName = 'Alexander';
+const correctedFirstName = 'Blexander';
 ```
 
-## Числа тоже неизменяемы
+Попытка «запихать» все строки в одну переменную запутывает код: переменная перестаёт говорить, что в ней хранится.
+
+## Вывод
 
-То же самое касается чисел и булевых значений — они не объекты с изменяемым состоянием, а просто значения.
+Примитивные типы данных в JavaScript (строки, числа, логические значения) являются неизменяемыми (immutable). Это означает, что после создания их значение изменить нельзя. Поменять один символ в строке невозможно — любые «изменения» происходят путём создания нового значения и переопределения переменной.