feat(33-data-types): adapt from Python + add casting lesson

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

@@ -1,31 +1,42 @@
+Все значения в программировании имеют **тип**. Тип определяет, какие операции можно выполнять с данными.
 
-Что произойдет, если мы попробуем умножить число на строку? JavaScript вернет `NaN` (не число) — то самое значение. Оно возникает там, где вместе используются несовместимые значения. В данном случае число и строка:
+## Примитивные типы в JavaScript
 
-```javascript
-3 * 'Dracarys'; // NaN
-```
+JavaScript имеет следующие примитивные типы:
 
-Внутри высокоуровневых языков программирования данные разделяются по типам. Любая строка относится к типу String, а числа — к типу Number и BigInt (очень большие числа). Зачем нужны типы? Для защиты программы от трудноотловимых ошибок. Типы определяют две вещи:
+| Тип | Примеры | Назначение |
+|-----|---------|------------|
+| `number` | `42`, `3.14`, `-7` | Числа (целые и дробные) |
+| `string` | `'hello'`, `"world"` | Текст |
+| `boolean` | `true`, `false` | Логические значения |
+| `null` | `null` | Намеренное отсутствие значения |
+| `undefined` | `undefined` | Неинициализированная переменная |
 
-* Возможные (допустимые) значения. Например, числа в JavaScript делятся на два типа: Number и BigInt. Первые — это все числа ниже определенного порога (его можно посмотреть), вторые — выше. Такое разделение связано с техническими особенностями работы аппаратуры.
-* Набор операций, которые можно выполнять над этим типом. Например, операция умножения имеет смысл для типа «целые числа». Но не имеет смысла для типа «строки»: умножать слово «мама» на слово «блокнот» — бессмыслица.
-
-JavaScript ведет себя двояко, когда встречается с нарушениями. В некоторых ситуациях, он ругается на недопустимость операции и завершается с ошибкой. В других — программа продолжает работать. В этом случае недопустимая операция возвращает что-то похожее на `NaN`, как в примере выше.
+```javascript
+const age = 25;            // number
+const name = 'Alice';      // string
+const isActive = true;     // boolean
+const nothing = null;      // null
+let unset;                 // undefined
+```
 
-Каким образом JavaScript понимает, что за тип данных перед ним? Достаточно просто. Любое значение где-то инициализируется и, в зависимости от способа инициализации, становится понятно, что перед нами. Например, числа — это просто числа без дополнительных символов, кроме  точки для рациональных чисел. А вот строки всегда ограничены специальными символами (в JavaScript три разных варианта). Например, такое значение `'234'` – строка, несмотря на то, что внутри нее записаны цифры.
+## Зачем нужны типы?
 
-JavaScript позволяет узнать тип данных с помощью оператора `typeof`:
+Тип влияет на поведение операций. Например, `+` для чисел — это сложение, а для строк — конкатенация:
 
 ```javascript
-typeof 3; // number
-typeof 'Game'; // string
+console.log(1 + 2);       // => 3
+console.log('1' + '2');   // => '12'
 ```
 
-Типы данных Number, BigInt и String — это *примитивные* типы. Но есть и другие. В JavaScript встроен составной тип Object (а на его базе массивы, даты и другие). С его помощью можно объединять данные разных типов в одно значение, например, мы можем создать пользователя добавив к нему имя и возраст.
+## Как узнать тип значения
+
+Оператор `typeof` возвращает тип в виде строки:
 
 ```javascript
-// Этот синтаксис изучается на Хекслете
-const user = { name: 'Toto', age: 33 };
+console.log(typeof 42);        // => 'number'
+console.log(typeof 'hello');   // => 'string'
+console.log(typeof true);      // => 'boolean'
+console.log(typeof undefined); // => 'undefined'
+console.log(typeof null);      // => 'object'  (историческая ошибка JS)
 ```
-
-По-английски строки в программировании называются "strings", а строчки текстовых файлов — "lines". Например, в коде выше есть две строчки (lines), но только одна строка (strings). В русском иногда может быть путаница, поэтому во всех уроках мы будем говорить **строка** для обозначения типа данных «строка», и **строчка** для обозначения строчек (lines) в файлах.

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

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

modules/33-data-types/55-data-types-casting/Makefile

@@ -0,0 +1,2 @@
+test:
+	@ test.sh

modules/33-data-types/55-data-types-casting/description.es.yml

@@ -0,0 +1,10 @@
+---
+
+name: Conversión de tipos explícita
+theory: |
+  Usa funciones Number(), String(), Boolean() para conversión explícita de tipos.
+
+instructions: |
+  Trunca la temperatura, conviértela a cadena y muestra el resultado con la unidad.
+
+tips: []

modules/33-data-types/55-data-types-casting/en/EXERCISE.md

@@ -0,0 +1 @@
+Given `temperature = 36.6`, truncate the decimal part, convert to string, and print `36 °C`.

modules/33-data-types/55-data-types-casting/en/README.md

@@ -0,0 +1,8 @@
+Use conversion functions to explicitly change a value's type.
+
+```javascript
+Number('42');    // => 42
+String(42);      // => '42'
+Boolean(0);      // => false
+Boolean('hi');   // => true
+```

modules/33-data-types/55-data-types-casting/en/data.yml

@@ -0,0 +1,5 @@
+---
+name: Type casting
+tips:
+  - >
+    [Number()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/Number)

modules/33-data-types/55-data-types-casting/es/EXERCISE.md

@@ -0,0 +1 @@
+Dada `temperature = 36.6`, trunca la parte decimal, convierte a cadena e imprime `36 °C`.

modules/33-data-types/55-data-types-casting/es/README.md

@@ -0,0 +1,6 @@
+Usa funciones de conversión para cambiar el tipo de un valor.
+
+```javascript
+Number('42');  // => 42
+String(42);    // => '42'
+```

modules/33-data-types/55-data-types-casting/es/data.yml

@@ -0,0 +1,3 @@
+---
+name: Conversión de tipos
+tips: []

modules/33-data-types/55-data-types-casting/index.js

@@ -0,0 +1,6 @@
+const temperature = 36.6;
+// BEGIN
+const intValue = Math.trunc(temperature);
+const strValue = String(intValue);
+console.log(strValue + ' °C');
+// END

modules/33-data-types/55-data-types-casting/ru/EXERCISE.md

@@ -0,0 +1,5 @@
+Дана константа `temperature = 36.6`. Напишите программу, которая:
+
+1. Отбрасывает дробную часть (`Math.trunc()`).
+2. Преобразует результат в строку (`String()`).
+3. Выводит строку с единицей измерения: `36 °C`.

modules/33-data-types/55-data-types-casting/ru/README.md

@@ -0,0 +1,38 @@
+JavaScript автоматически преобразует типы в некоторых ситуациях (неявное преобразование). Но иногда нужно преобразовать тип **явно** — когда точно знаете, что хотите получить.
+
+## Функции преобразования
+
+```javascript
+Number('42');       // => 42      (строка → число)
+Number('3.14');     // => 3.14
+Number('hello');    // => NaN     (не число)
+
+String(42);         // => '42'    (число → строка)
+String(true);       // => 'true'
+
+Boolean(0);         // => false
+Boolean('');        // => false
+Boolean('hello');   // => true
+Boolean(1);         // => true
+```
+
+## Когда это нужно
+
+Чаще всего при работе с пользовательским вводом (всё приходит как строка) или при формировании текстовых сообщений из чисел.
+
+```javascript
+const price = 100;
+const message = 'Цена: ' + String(price) + ' руб.';
+// Хотя в этом случае удобнее интерполяция: `Цена: ${price} руб.`
+```
+
+## Math.trunc() для целой части
+
+Чтобы отбросить дробную часть числа, используют `Math.trunc()`:
+
+```javascript
+Math.trunc(36.6);  // => 36
+Math.trunc(-36.6); // => -36
+```
+
+В отличие от `Math.floor()`, `Math.trunc()` просто отбрасывает дробную часть независимо от знака.

modules/33-data-types/55-data-types-casting/ru/data.yml

@@ -0,0 +1,12 @@
+---
+name: Явное преобразование типов
+tips:
+  - >
+    [Number()](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Number/Number)
+  - >
+    [String()](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/String/String)
+definitions:
+  - name: Явное преобразование типов
+    description: >-
+      намеренное приведение значения к другому типу с помощью функций
+      Number(), String(), Boolean().

modules/33-data-types/55-data-types-casting/test.js

@@ -0,0 +1,12 @@
+// @ts-check
+
+import { expect, test, vi } from 'vitest';
+
+test('hello world', async () => {
+  const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  await import('./index.js');
+
+  const firstArg = consoleLogSpy.mock.calls.join('\n');
+
+  expect(firstArg).toBe('36 °C');
+});