Переменные, типы данных, приведение типов

01 Переменные: let, const и почему не var

Переменная — это именованное место в памяти, куда программа кладёт значение, чтобы потом достать его по имени. Вместо того чтобы писать число 25 в десяти местах, вы записываете его один раз и дальше пользуетесь именем.

let price = 25;
console.log(price);        // → 25

price = 30;                // новое значение
console.log(price);        // → 30
console.log(price * 2);    // → 60

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

let

Переменная, значение которой можно менять: баланс, счётчик, имя пользователя.

const

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

var

Старый способ из эпохи до 2015 года. Работает, но ведёт себя неожиданно. В новом коде не используем.

const academy = "MakeFirstStep";   // не меняется
let students = 12;            // будет меняться

students = 13;                // пришёл новый студент
console.log(academy, students);   // → MakeFirstStep 13

Что будет, если изменить const

JavaScript остановит программу и покажет ошибку. Это не поломка, а защита: вы сами сказали, что значение не должно меняться.

const rate = 10.95;
console.log("Курс:", rate);

rate = 11;   // ✖ TypeError: Assignment to constant variable.
console.log("Новый курс:", rate);

Обратите внимание: строка с "Новый курс" не выполнилась. После ошибки программа останавливается. Умение читать текст ошибки — один из главных навыков программиста: TypeError — «тип ошибки», после двоеточия — понятное описание.

Объявить и присвоить — разные вещи

• Объявление — слово let или const и имя. Делается один раз.
• Присваивание — знак =. Можно делать много раз (для let).
• У const значение нужно задать сразу при объявлении: const x; — ошибка.
• У let можно объявить без значения: let result; — внутри будет undefined («не определено»). Про него поговорим в разделе о типах.

let result;                 // объявили, значения пока нет
console.log(result);        // → undefined

result = 100;               // присвоили
console.log(result);        // → 100

Почему не var

У var три неприятные особенности. Вы будете встречать его в старых учебниках и в ответах ИИ, поэтому важно понимать, в чём проблема.

1. «Протекает» из фигурных скобок. Код в { } — это блок. Переменная let остаётся внутри блока, а var выходит наружу:

{
  var oldWay = "var видно снаружи";
  let newWay = "let живёт только внутри";
  console.log(newWay);        // → let живёт только внутри
}

console.log(oldWay);          // → var видно снаружи

{
  let newWay = "let живёт только внутри";
}

console.log(newWay);   // ✖ ReferenceError: newWay is not defined

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

var city = "Душанбе";
var city = "Худжанд";      // JavaScript молчит, хотя имя уже занято
console.log(city);         // → Худжанд

let city = "Душанбе";
let city = "Худжанд";      // ✖ SyntaxError: Identifier 'city' has already been declared
console.log(city);

3. «Поднимается»: var можно использовать до строки с объявлением — получите undefined вместо понятной ошибки. С let и const JavaScript честно скажет, что вы поторопились.

console.log(a);   // → undefined (странно, но без ошибки)
var a = 5;
console.log(a);   // → 5

console.log(b);   // ✖ ReferenceError: Cannot access 'b' before initialization
let b = 5;

Как называть переменные

let x = 25;
let a1 = "Мадина";
let data = 3;
let sum_of_the_all = 100;

let samsaPrice = 25;
let studentName = "Мадина";
let seatsCount = 3;
let totalSum = 100;

Читать подробнее: learn.javascript.ru — Переменные · MDN — Грамматика и типы

// объявите city и temperature


// измените temperature на 17


// выведите оба значения

Душанбе 17

const balance = 100;
balance = balance + 50;   // пополнили на 50 сомони
console.log("Баланс:", balance);

Баланс: 150

02 Типы данных и typeof

Значения бывают разных типов. Число 25 и текст "25" выглядят похоже, но для JavaScript это совершенно разные вещи: числа можно умножать, а текст — склеивать и показывать. Тип определяет, что со значением можно делать.

Пять основных типов

Узнать тип значения помогает оператор typeof. Он возвращает строку с названием типа:

console.log(typeof "Салом");     // → string
console.log(typeof 25);          // → number
console.log(typeof 3.14);        // → number  (дробные — тоже number)
console.log(typeof true);        // → boolean
console.log(typeof undefined);   // → undefined

typeof работает и с переменными — он смотрит на значение внутри:

const dish = "курутоб";
const price = 35;
const isSpicy = false;

console.log(dish, typeof dish);       // → курутоб string
console.log(price, typeof price);     // → 35 number
console.log(isSpicy, typeof isSpicy); // → false boolean

console.log(typeof 25);     // → number
console.log(typeof "25");   // → string
console.log(typeof true);   // → boolean
console.log(typeof "true"); // → string — это просто текст из четырёх букв

null и undefined: в чём разница

let phone;                 // объявили, но не присвоили
console.log(phone);        // → undefined

let nickname = null;       // мы сами решили: ника нет
console.log(nickname);     // → null

Обычно undefined появляется «сам» (JavaScript говорит: «тут пусто, потому что вы ничего не положили»), а null программист записывает осознанно: «сейчас значения нет».

console.log(typeof null);       // → object  (!)
console.log(typeof undefined);  // → undefined
console.log(null === undefined);// → false — «строго равно»: это разные значения (подробнее в разделе 6)

Тип у переменной не закреплён

В JavaScript переменная может хранить значение любого типа и менять его. Это называют динамической типизацией. Удобно, но требует внимания: переменная, в которой было число, вдруг оказывается строкой — и посчитать уже не получится.

let value = 100;
console.log(typeof value);   // → number

value = "сто";
console.log(typeof value);   // → string

value = true;
console.log(typeof value);   // → boolean

Ещё два типа — только знакомство

• bigint — очень большие целые числа, пишутся с буквой n на конце: 12345678901234567890n. Обычный number точен лишь до 9 007 199 254 740 991. Вам это понадобится редко.
• symbol — уникальный «идентификатор», создаётся командой Symbol("id"). В этом курсе не потребуется.

console.log(typeof 123n);             // → bigint
console.log(typeof Symbol("id"));     // → symbol

Есть ещё «составной» тип object — для списков и объектов. Его мы разберём на уроках 6 и 7, а пока в нашем списке всего пять основных примитивных типов.

Читать подробнее: learn.javascript.ru — Типы данных · MDN — typeof

const price = 25;
const dish = "самбуса";
const isHot = true;
let discount;
const comment = null;

// выведите typeof каждой переменной

number
string
boolean
undefined
object

// Впишите прогноз: тип каждого значения по порядку (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", "", "", "", "", ""];
const actual = [
  typeof 42,
  typeof "42",
  typeof 4.2,
  typeof NaN,
  typeof null,
  typeof undefined,
  typeof (5 > 3),
  typeof 10n,
  typeof Symbol("id"),
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

03 Строки и шаблонные литералы

Строка — это текст. Её пишут в кавычках, и кавычки бывают трёх видов:

const a = "двойные кавычки";
const b = 'одинарные кавычки';
const c = `обратные кавычки — шаблонная строка`;

console.log(a);
console.log(b);
console.log(c);

Двойные и одинарные — одно и то же, выберите один стиль и держитесь его. Если внутри текста нужны такие же кавычки, их «экранируют» обратной косой чертой:

console.log("Он сказал: \"Салом!\"");     // → Он сказал: "Салом!"
console.log('Сумма: 5 сомони\nИтого: 10');  // \n — перенос строки

Склейка строк через +

Знак + между строками их склеивает. Это называется конкатенация:

const name = "Мадина";
console.log("Салом, " + name + "!");   // → Салом, Мадина!

Работает, но с несколькими значениями быстро превращается в кашу из кавычек и плюсов — и легко забыть пробел.

Шаблонные литералы

Строка в обратных кавычках `…` позволяет вставлять значения прямо в текст через ${ }. Внутри скобок можно писать любые выражения.

const name = "Мадина";
const age = 19;
const price = 25;

console.log(`Салом, ${name}!`);                     // → Салом, Мадина!
console.log(`${name}, вам ${age} лет`);              // → Мадина, вам 19 лет
console.log(`Три самбусы стоят ${price * 3} сомони`);// → Три самбусы стоят 75 сомони
console.log(`Через год вам будет ${age + 1}`);       // → Через год вам будет 20

Ещё одно удобство: шаблонная строка может занимать несколько строк — переносы сохранятся как есть.

const student = "Фарход";
const grade = 5;

console.log(`Ведомость
Студент: ${student}
Оценка: ${grade}`);

Строка — это ещё и набор команд

У каждой строки есть свойства и команды, которые записываются через точку. Сейчас нам хватит нескольких — как они устроены внутри, узнаем на уроках про функции и объекты.

const city = "  Душанбе  ";

console.log(city.length);              // → 11 — количество символов (с пробелами!)
console.log(city.trim());              // → Душанбе — убрали пробелы по краям
console.log(city.trim().toUpperCase()); // → ДУШАНБЕ
console.log(city.trim().toLowerCase()); // → душанбе
console.log("Салом"[0]);               // → С — первый символ (счёт идёт с нуля)
console.log("Салом"[4]);               // → м — пятый символ

• .length — длина строки (без скобок: это свойство);
• .toUpperCase() / .toLowerCase() — заглавные / строчные;
• .trim() — убирает пробелы с начала и конца;
• [0], [1] … — символ по номеру; нумерация начинается с нуля.

const name = "Далер";
console.log("Привет, ${name}");   // → Привет, ${name}  (не сработало!)
console.log(`Привет, ${name}`);   // → Привет, Далер

Читать подробнее: learn.javascript.ru — Строки · MDN — Шаблонные литералы

const name = "Мадина";
const age = 19;
const city = "Душанбе";

// выведите: Меня зовут Мадина, мне 19 лет, живу в Душанбе

Меня зовут Мадина, мне 19 лет, живу в Душанбе

const orderNumber = 15;
const dish = "Самбуса";
const count = 3;
const price = 5;

// чек из трёх строк — в одном console.log

Чек №15
Самбуса x 3
Итого: 15 сомони

04 Числа и операторы

В JavaScript все числа — одного типа number: и целые (25), и дробные (3.14, дробная часть через точку). Для вычислений есть операторы — знаки действий.

console.log(7 + 3);     // → 10
console.log(7 / 2);     // → 3.5 — деление не округляет
console.log(17 % 5);    // → 2
console.log(2 ** 10);   // → 1024
console.log(2 + 3 * 4); // → 14 — умножение выполняется раньше сложения
console.log((2 + 3) * 4); // → 20 — скобки меняют порядок

const manti = 17;
const plates = 5;

console.log(`Полных тарелок: ${Math.floor(manti / plates)}`);  // → 3
console.log(`Осталось манты: ${manti % plates}`);             // → 2
console.log(10 % 2);   // → 0 — чётное
console.log(7 % 2);    // → 1 — нечётное

Округление: Math.round, floor, ceil

Деление часто даёт дробь. Для округления есть три команды, которые начинаются с Math.:

console.log(Math.round(2.5));  // → 3 — до ближайшего целого
console.log(Math.round(2.4));  // → 2
console.log(Math.floor(2.9));  // → 2 — всегда вниз
console.log(Math.ceil(2.1));   // → 3 — всегда вверх

Сокращённая запись: +=, ++ и компания

Менять значение переменной нужно постоянно: прибавить к балансу, увеличить счётчик. Для этого есть короткие формы:

let balance = 100;

balance = balance + 20;   // длинная запись
balance += 20;            // то же самое, коротко
console.log(balance);     // → 140

balance -= 40;            // balance = balance - 40
balance *= 2;             // balance = balance * 2
console.log(balance);     // → 200

let visitors = 0;
visitors++;               // увеличить на 1
visitors++;
console.log(visitors);    // → 2
visitors--;               // уменьшить на 1
console.log(visitors);    // → 1

Знаки ++ и -- можно писать перед переменной и после. Если вы просто увеличиваете число отдельной строкой, разницы нет. Но если значение ещё и используется в этой же строке — разница есть:

let a = 5;
console.log(a++);   // → 5  — сначала отдали старое значение, потом увеличили
console.log(a);     // → 6

let b = 5;
console.log(++b);   // → 6  — сначала увеличили, потом отдали
console.log(b);     // → 6

Сравнения дают boolean

Знаки >, <, >=, <=, === (равно) и !== (не равно) сравнивают значения и возвращают true или false. Условия if, которые на этом строятся, мы будем изучать на уроке 3.

console.log(5 > 3);        // → true
console.log(5 < 3);        // → false
console.log(10 >= 10);     // → true
console.log(7 === 7);       // → true
console.log(7 !== 7);       // → false

Infinity и NaN

В математике на ноль делить нельзя. JavaScript не падает, а возвращает особое значение:

console.log(1 / 0);     // → Infinity — «бесконечность»
console.log(-1 / 0);    // → -Infinity
console.log(0 / 0);     // → NaN — «не число» (Not a Number)

NaN появляется, когда арифметика не получилась: например, умножили текст на число. Запомните три свойства NaN:

• по типу это всё равно number: typeof NaN → "number";
• оно «заразное»: любое действие с NaN тоже даёт NaN;
• NaN не равно даже самому себе. Проверять надо командой Number.isNaN(x).

console.log("abc" * 2);              // → NaN
console.log(NaN + 5);                // → NaN — заразилось
console.log(NaN === NaN);            // → false (!)
console.log(Number.isNaN(NaN));      // → true
console.log(Number.isNaN("abc"));    // → false — это строка, не NaN

console.log(0.1 + 0.2);            // → 0.30000000000000004
console.log(0.1 + 0.2 === 0.3);    // → false

Что делать с деньгами: считать в наименьших единицах — в дирамах (1 сомони = 100 дирамов), то есть в целых числах, и делить на 100 только при показе. А красивый вывод с двумя знаками даёт .toFixed(2) — но помните: он возвращает строку, а не число.

const total = 0.1 + 0.2;
console.log(total.toFixed(2));          // → 0.30
console.log(typeof total.toFixed(2));   // → string — это уже текст!

console.log((10 + 20) / 100);           // → 0.3 — считали в дирамах (10 и 20), потом разделили

Читать подробнее: learn.javascript.ru — Базовые операторы · learn.javascript.ru — Числа

const manti = 17;
const perPlate = 5;

// выведите две строки

Полных тарелок: 3
Осталось: 2

let seats = 20;

// 1) пришли трое — seats -= 3
// 2) пришёл ещё один — seats--
// 3) двое ушли — seats += 2

console.log("Свободных мест:", seats);

Свободных мест: 18

05 Явное приведение типов

Приведение типов — превращение значения из одного типа в другой. Оно бывает явным (вы сами просите: «сделай из этого число») и неявным (JavaScript делает это сам, не спрашивая — разберём в следующем разделе). Сначала учимся делать это осознанно.

В строку: String()

console.log(String(123));         // → "123"
console.log(String(true));        // → "true"
console.log(String(null));        // → "null"
console.log(String(undefined));   // → "undefined"
console.log(typeof String(123));  // → string

В число: Number()

Самое важное преобразование. В реальной работе числа часто приходят как текст: из поля ввода, из ответа сервера. Пробелы по краям Number() убирает, а вот лишний текст внутри — нет.

console.log(Number("42"));        // → 42
console.log(Number("3.14"));      // → 3.14
console.log(Number("  7  "));     // → 7    — пробелы по краям отбрасываются
console.log(Number("12px"));      // → NaN  — внутри есть лишние символы
console.log(Number("abc"));       // → NaN
console.log(Number(""));          // → 0    — пустая строка даёт ноль (!)
console.log(Number(true));        // → 1
console.log(Number(false));       // → 0
console.log(Number(null));        // → 0
console.log(Number(undefined));   // → NaN

«Достать» число из текста: parseInt и parseFloat

Number() строгий: любой лишний символ — NaN. А parseInt() и parseFloat() читают строку слева направо, пока видят цифры, и останавливаются на первом лишнем символе. parseInt возвращает целое, parseFloat — дробное.

console.log(parseInt("42px"));       // → 42
console.log(parseInt("3.99"));       // → 3     — дробная часть отброшена (не округлена!)
console.log(parseFloat("3.99kg"));   // → 3.99
console.log(parseFloat("2.5 кг"));   // → 2.5
console.log(parseInt("px42"));       // → NaN   — начало не с цифры
console.log(parseInt("abc"));        // → NaN

Совет профессионалов: parseInt(text, 10) — второй аргумент 10 явно говорит «в десятичной системе». В современных браузерах без него тоже работает, но с ним код надёжнее и понятнее.

В логическое значение: Boolean()

Любое значение можно превратить в true или false. Правило простое: «пустые» значения дают false, все остальные — true. «Пустых» (их называют falsy) всего шесть основных:

• false — сам по себе;
• 0 (и -0);
• "" — пустая строка;
• null;
• undefined;
• NaN.

console.log(Boolean(0));            // → false
console.log(Boolean(""));           // → false
console.log(Boolean(null));         // → false
console.log(Boolean(undefined));    // → false
console.log(Boolean(NaN));          // → false

console.log(Boolean(1));            // → true
console.log(Boolean(-5));           // → true  — любое число, кроме нуля
console.log(Boolean("Салом"));      // → true
console.log(Boolean(" "));          // → true  — пробел это уже символ!
console.log(Boolean("0"));          // → true  — строка "0" не пустая
console.log(Boolean("false"));      // → true  — и это тоже просто текст

Куда приходят строки в реальных проектах

Значения из полей ввода на странице и из окна prompt() всегда приходят строками, даже если пользователь ввёл цифры. Поэтому Number() придётся писать очень часто. В нашей учебной консоли prompt() недоступен, но вот как это выглядит в браузере:

const answer = prompt("Сколько вам лет?");   // пользователь ввёл 19
console.log(typeof answer);                   // → string — всегда строка!

const age = Number(answer);
console.log(age + 1);                         // → 20

Читать подробнее: learn.javascript.ru — Преобразование типов · MDN — parseInt · MDN — Falsy

const priceText = "45";
const countText = "3";

// посчитайте итог и выведите его и его тип

Итого: 135
number

const weight = "2.5 кг";
const pricePerKg = 18;

// выведите: Цена: 45 сомони

Цена: 45 сомони

06 Неявное приведение: главные ловушки

Если в выражении встречаются значения разных типов, JavaScript сам приводит их к общему виду — и не предупреждает. Иногда это удобно, но чаще становится источником странных ошибок. Ваша задача — понимать правила и уметь предсказывать результат.

Правило 1: «+» с текстом — это склейка

Если хотя бы одна сторона + — строка, JavaScript превращает вторую в строку и склеивает.

console.log("5" + 3);        // → 53   — не 8!
console.log(3 + "5");        // → 35
console.log("Итого: " + 100);// → Итого: 100
console.log("5" + true);     // → 5true
console.log("5" + null);     // → 5null

Правило 2: остальные арифметические знаки превращают в числа

console.log("5" - 3);        // → 2
console.log("5" * "2");      // → 10
console.log("10" / "2");     // → 5
console.log("abc" * 2);      // → NaN — превратить в число не получилось

Правило 3: boolean, null и undefined в вычислениях

console.log(true + 1);       // → 2    — true становится 1
console.log(false + 1);      // → 1    — false становится 0
console.log(null + 1);       // → 1    — null становится 0
console.log(undefined + 1);  // → NaN  — undefined становится NaN

Порядок слева направо

Выражение вычисляется по шагам слева направо. Пока слева числа — они складываются, а как только в цепочке появилась строка — дальше идёт склейка:

console.log(1 + 2 + "3");    // → 33   — сначала 1 + 2 = 3, потом "3" + "3"
console.log("1" + 2 + 3);    // → 123  — сначала "1" + 2 = "12", потом "12" + 3
console.log(1 + 2 + 3);      // → 6

Унарный плюс: короткая запись Number()

Плюс перед значением без левой части превращает его в число — так же, как Number(). Это можно увидеть в чужом коде, а вот своём лучше писать явно.

console.log(+"7");           // → 7
console.log(+"");            // → 0
console.log(+"abc");         // → NaN
console.log(typeof +"7");    // → number
console.log("b" + "a" + +"a" + "a");   // → baNaNa  — известная шутка про NaN

Сравнения: == и ===

Есть два способа проверить равенство. Двойное == «нестрогое» — приводит типы и поэтому ведёт себя странно. Тройное === «строгое» — сравнивает без приведения: значения равны, только если и значение, и тип совпадают.

console.log(5 == "5");        // → true   — привело строку к числу
console.log(5 === "5");       // → false  — разные типы
console.log(0 == "");         // → true   (!)
console.log(0 == false);      // → true   (!)
console.log("0" == false);    // → true   (!)
console.log(null == undefined);   // → true
console.log(null === undefined);  // → false
console.log(null == 0);       // → false  — вот такая непоследовательность

Сравнение строк — по буквам

Две строки сравниваются посимвольно, как слова в словаре, а не как числа. Поэтому «10» оказывается «меньше» «9»: первая цифра 1 меньше, чем 9.

console.log("10" > "9");     // → false (!)  — строки сравниваются по символам
console.log("10" > 9);       // → true       — одно из значений число, значит сравнивает как числа
console.log(Number("10") > Number("9"));  // → true — надёжный способ

Шпаргалка по ловушкам

Читать подробнее: learn.javascript.ru — Сравнения · learn.javascript.ru — Преобразование типов

// Впишите прогноз: результат каждого выражения по порядку (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", "", ""];
const actual = [
  "5" + 3,
  "5" - 3,
  "5" * "2",
  true + 1,
  null + 1,
  undefined + 1,
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const price = "25";
const count = "4";

const total = price + count;
console.log("Итого:", total);

Итого: 100

07 ИИ-блок: анатомия промпта и «ловим ИИ на ошибке»

ИИ-помощник отвечает ровно на тот вопрос, который вы ему задали. Расплывчатый вопрос — расплывчатый ответ, который к тому же может содержать ошибку. Поэтому в этом курсе у нас два навыка: правильно спрашивать (промпт) и проверять ответ (запустить и сверить).

Анатомия промпта: четыре обязательных части

Хороший промпт — это не длинный текст, а структура. Запомните порядок: контекст → задача → ограничения → формат ответа. Пятый пункт — проверка — мы добавляем, когда нужен ответ, которому нельзя слепо доверять (то есть почти всегда).

Чем сильный промпт лучше: ИИ не гадает, какой у вас уровень, не использует незнакомые вам конструкции, отвечает в удобной форме и сам даёт вам материал для самопроверки.

Собираем свой шаблон промпта

Каждый раз писать структуру с нуля долго. Сделайте свой шаблон — заготовку, которую вы будете копировать и заполнять. Это ваш первый артефакт курса: он пойдёт в конспект по промптам, а потом — в личную шпаргалку, которую сдают на уроке 21.

1. Скопируйте заготовку ниже в свой конспект (файл или заметки).
2. Заполните «постоянные» поля один раз: в «Контексте» напишите свой уровень и стек («чистый JavaScript, без библиотек, новичок»). Это будет одинаково в каждом промпте.
3. Придумайте свою «любимую» строку в «Проверке»: например, «покажи, что выведет консоль» или «назови 2 крайних случая». Её вы тоже оставите навсегда.
4. Протестируйте шаблон на задаче из урока: заполните поля и отправьте ИИ. Если ответ вас не устроил — уточните, в какой из четырёх частей не хватило деталей, и поправьте шаблон.

Как читать ответ ИИ: проверяем, а не верим

ИИ пишет уверенно — даже когда ошибается. На теме типов это особенно заметно: неявное приведение и странности вроде typeof null он нередко пересказывает неверно. Поэтому у вас есть простой алгоритм:

1. Прогнозируйте. Прочитали объяснение ИИ — запишите, какой результат должен получиться.
2. Запускайте. Скопируйте пример в консоль и посмотрите, что выведется на самом деле.
3. Сверяйте. Совпало — отлично. Не совпало — ошибся либо ИИ, либо вы. Разберитесь, кто именно: в этом и есть обучение.
4. Переспрашивайте. Покажите ИИ реальный вывод: «в консоли получилось X, а ты говорил Y — объясни расхождение».

console.log("10" + 5);

// допишите строку, которая выведет 15

105
15

console.log("null");        // должно быть typeof null
console.log("NaN");         // должно быть typeof NaN
console.log("undefined");   // должно быть typeof undefined

object
number
undefined

console.log(Boolean("0"));
console.log(Boolean(""));
console.log(Boolean(" "));
console.log(Boolean(0));

// допишите: Ошибки ИИ: ...

true
false
true
false
Ошибки ИИ: 1 3

Читать подробнее: learn.javascript.ru — Преобразование типов · MDN — Falsy

08 Практика на уроке: 15 мини-задач на типы

Это основная часть занятия. Пятнадцать коротких задач — от простых к сложным. В каждой действует один и тот же ритм:

1. Прочитайте условие и код.
2. Предскажите результат — запишите в тетрадь.
3. Запустите и сверьте. Расхождение — повод вспомнить правило из урока.
4. Объясните соседу по парте, почему получилось именно так — вслух и своими словами.

// объявите переменные и выведите строку

Фарход, 20 лет, студент: true

// Впишите прогноз: результат каждого выражения по порядку (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", ""];
const actual = [
  10 / 4,
  10 % 4,
  2 ** 5,
  7 - "2",
  "7" + 2,
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const ticket = "15";
console.log(typeof ticket);

// превратите ticket в число: const ticketNum = ...

console.log(typeof ticketNum);

string
number

// Впишите прогноз: результат каждого выражения по порядку (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", ""];
const actual = [
  5 / 0,
  -5 / 0,
  0 / 0,
  "abc" * 3,
  typeof (0 / 0),
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const city = "душанбе";

// первая буква — заглавная, остальные — как были

Душанбе
7

const g1 = "5";
const g2 = "4";
const g3 = "5";

// выведите: Средний балл: 4.7

Средний балл: 4.7

// Впишите прогноз: true или false для каждого значения (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", "", ""];
const actual = [
  Boolean(0),
  Boolean(""),
  Boolean("0"),
  Boolean(null),
  Boolean("false"),
  Boolean(NaN),
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

let n = 10;

// +5, *2, -3, /3, в квадрат

console.log("n =", n);

n = 81

// Впишите прогноз: пять значений, которые вернут выражения по порядку (текстом)
const prediction = ["", "", "", "", ""];
let a = 3;
const actual = [a++, a, ++a, a--, a].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const minutes = 275;

// выведите: В пути: 4 ч 35 мин

В пути: 4 ч 35 мин

// Впишите прогноз: шесть значений по порядку (текстом)
const prediction = ["", "", "", "", "", ""];
let a;
const b = null;
const actual = [a, b, typeof a, typeof b, a == b, a === b].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

// Впишите прогноз: результат каждого выражения по порядку (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", ""];
const actual = [
  1 + "2" + 3,
  "3" * "4" + 1,
  10 - "2" + "2",
  "4" + 4 * 2,
  10 / "5" + "1",
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const n = 2587;

// выведите три строки

Последняя цифра: 7
Без неё: 258
Чётное: false

const a = 0.1;
const b = 0.2;

console.log("Наивно:", a + b);

// посчитайте через дирамы и выведите: Точно: 0.3

Наивно: 0.30000000000000004
Точно: 0.3

const priceText = "200";
const countText = "3";
const TAX = 1.15;

// выведите: К оплате: 690 сомони

К оплате: 690 сомони

09 Домашнее задание

Домашняя работа — 10 задач и конспект по промптам. Результат: файл tasks-02.js и конспект с промптами. Решения пишите в обычном файле — запускайте через консоль браузера (вставляйте код) или в VS Code.

10 задач

1. Паспорт данных. Объявите 8 переменных разных типов (string, number, boolean, null, undefined и ещё три на ваш выбор). Для каждой выведите значение и typeof.
2. Моя визитка. Данные о себе (имя, возраст, город, любимое блюдо) положите в const. Выведите многострочную визитку одним console.log с шаблонной строкой.
3. Конвертер валют. Курс USD_RATE = 10.95 положите в const. Сумма в долларах пришла строкой "250". Выведите сумму в сомони, округлив до двух знаков через toFixed(2).
4. Предскажи 8 выражений. Составьте самостоятельно 8 выражений с неявным приведением (+, -, *, true, null, undefined). Запишите прогноз, затем запустите и сверьте.
5. Часы и минуты. По количеству секунд (например, 10000) выведите время в формате «часы : минуты : секунды». Используйте Math.floor и %.
6. Починить три фрагмента. Напишите три коротких фрагмента с ошибкой приведения типов (склейка вместо сложения; NaN из-за undefined; нестрогое сравнение), а ниже — исправленную версию каждого.
7. Falsy-детектор. Выведите Boolean(...) для 12 разных значений (0, "", " ", "0", null, undefined, NaN, -1 и др.). Рядом комментарием — ваш прогноз.
8. Охота на NaN и Infinity. Найдите три разных способа получить NaN и два — Infinity. Проверьте NaN через Number.isNaN.
9. Деньги без ошибок. Корзина: три товара с ценами в сомони с копейками (например, 12.40, 7.35, 0.10). Посчитайте итог через дирамы (целыми числами) и выведите в сомони.
10. Один хороший промпт. Составьте промпт по формуле «контекст → задача → ограничения → формат» на любую задачу из этого урока. Запишите его в конспект (см. ниже).

Работа с ИИ и конспект по промптам

Что сдать

• tasks-02.js — решения 10 задач с комментариями-прогнозами;
• prompts-02.md — конспект по промптам: ваш шаблон из урока + три разбора «промпт → ответ → ошибка/проверка»;
• оба файла — в репозиторий на GitHub (ссылку пришлите преподавателю).

Как оценивается (0–10)