Циклы

01 Зачем нужны циклы. Цикл while

Представьте, что вы встречаете пятерых гостей на пороге MakeFirstStep. Без циклов код выглядит так:

console.log("Гость №1, добро пожаловать!");
console.log("Гость №2, добро пожаловать!");
console.log("Гость №3, добро пожаловать!");
console.log("Гость №4, добро пожаловать!");
console.log("Гость №5, добро пожаловать!");

Пять строк — ещё терпимо. А если гостей 500? А если их число заранее неизвестно? Здесь и приходит на помощь цикл — конструкция, которая повторяет блок кода, пока выполняется условие. Самый простой цикл — while («пока»):

let i = 1;                 // 1. старт: счётчик начинается с 1
while (i <= 5) {           // 2. условие: повторяем, пока оно true
  console.log(`Гость №${i}, добро пожаловать!`);
  i++;                     // 3. шаг: меняем счётчик
}
console.log("Все гости встречены");

Как работает while — по шагам

1. Проверка условия. JavaScript вычисляет выражение в скобках после while. Это то же самое выражение, что и в if: true или false.
2. Если true — выполняется всё, что в фигурных скобках. Это тело цикла.
3. Возврат к шагу 1. Дошли до закрывающей скобки — снова проверяем условие.
4. Если false — цикл заканчивается, программа идёт дальше, к строке после }.

Один проход по телу называется итерацией (или «кругом»). Вот что происходит в нашем примере:

Тело цикла

Код в фигурных скобках, который повторяется.

Условие

Выражение, которое проверяется перед каждым кругом. true — крутимся дальше, false — выходим.

Итерация

Один круг цикла: один проход по телу.

Счётчик

Переменная, которая меняется от круга к кругу и в итоге делает условие ложным. Обычно её называют i.

while, когда число кругов заранее неизвестно

Главная сила while — ситуации «делай, пока не случится что-то». Например, пока хватает денег на чай:

let money = 20;          // сомони в кошельке
const teaPrice = 6;      // цена чайника чая

while (money >= teaPrice) {
  money -= teaPrice;
  console.log(`Выпили чай. Осталось: ${money} сомони`);
}
console.log("Денег на чай больше нет");

Сколько чайников получится — заранее не видно, цикл сам посчитал. Если же число повторений известно сразу («ровно 5 гостей»), удобнее другая запись — for, о ней в следующем разделе.

let n = 10;
while (n < 5) {
  console.log("Сюда мы не попадём");
  n++;
}
console.log("Конец, n =", n);   // → Конец, n = 10

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

let i = 1;
// ваш цикл while здесь

Студент №1, проходите в аудиторию
Студент №2, проходите в аудиторию
Студент №3, проходите в аудиторию
Студент №4, проходите в аудиторию

let seconds = 5;
// цикл while здесь

console.log("Начали!");

5
4
3
2
1
Начали!

const goal = 30;
let saved = 0;
let day = 0;
// цикл: пока saved меньше goal

День 1: накоплено 5 сомони
День 2: накоплено 10 сомони
День 3: накоплено 15 сомони
День 4: накоплено 20 сомони
День 5: накоплено 25 сомони
День 6: накоплено 30 сомони

02 Цикл for

В цикле while три важные части — старт, условие и шаг — разбросаны по коду: старт выше цикла, шаг в конце тела. Легко что-то забыть. Цикл for собирает всё это в одну строку:

for (let i = 1; i <= 5; i++) {
  console.log(`Гость №${i}, добро пожаловать!`);
}

Результат тот же, что у while в прошлом разделе, но кода меньше и все три части видны сразу.

В каком порядке всё выполняется

1. Старт let i = 1 выполняется один раз, самым первым.
2. Условие i <= 5 проверяется перед каждым кругом. false — выход из цикла.
3. Тело выполняется целиком.
4. Шаг i++ выполняется после тела. Затем снова шаг 2.

Разные варианты заголовка

Меняя три части, можно считать как угодно: с нуля, с шагом, назад.

console.log("--- с шагом 5 ---");
for (let i = 0; i <= 20; i += 5) {
  console.log(i);
}

console.log("--- назад ---");
for (let i = 3; i >= 1; i--) {
  console.log(`Осталось ${i}`);
}

for (let i = 1; i < 5; i++) {
  console.log(`Урок ${i}`);   // 5-й урок потерялся!
}

Переменная цикла живёт только внутри

for (let i = 1; i <= 3; i++) {
  console.log(i);
}
console.log(i);   // ✖ i не существует вне цикла

Это нормально и даже удобно: каждый цикл имеет собственную i, и циклы друг другу не мешают. Если значение нужно после цикла, объявляйте переменную до него. Почему так устроено — расскажем на уроке про функции.

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

const price = 5;
// for ...

1 шт. — 5 сомони
2 шт. — 10 сомони
3 шт. — 15 сомони
4 шт. — 20 сомони
5 шт. — 25 сомони

for (let i = 0; i < 5; i++) {
  console.log(`Урок ${i}`);
}

Урок 1
Урок 2
Урок 3
Урок 4
Урок 5

for (let i = 3; i > 0; i--) {
  console.log("A" + i);
}

for (let i = 0; i < 10; i += 4) {
  console.log("B" + i);
}

// третий цикл здесь

A3
A2
A1
B0
B4
B8
C10
C7
C4
C1

03 Цикл do..while

У while есть брат-близнец: do..while («делай, пока»). Разница одна, но важная: условие проверяется после тела, поэтому тело выполнится минимум один раз, даже если условие ложно с самого начала.

let attempt = 0;

do {
  attempt++;
  console.log(`Попытка входа №${attempt}`);
} while (attempt < 3);

Обратите внимание на точку с запятой после while (…) — в do..while она нужна. Теперь сравните оба цикла, когда условие ложно сразу:

let cups = 0;

while (cups > 0) {
  console.log("while: тело выполнилось");
}

do {
  console.log("do..while: тело выполнилось");
} while (cups > 0);

Читать подробнее: MDN — do...while · learn.javascript.ru — Цикл do..while

const log = [];   // сюда код собирает «вывод»
let n = 10;
while (n < 5) {
  log.push(`while: n = ${n}`);
  n++;
}
do {
  log.push(`do..while: n = ${n}`);
  n++;
} while (n < 5);
log.push(`Итог: n = ${n}`);

const prediction = [];   // ваш прогноз: строки вывода по порядку, например ["do: n = 1", …]
console.log(log.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

let balance = 100;
// do { ... } while (...);

console.log(`Итоговый остаток: ${balance}`);

Выдано 30 сомони, остаток: 70
Выдано 30 сомони, остаток: 40
Выдано 30 сомони, остаток: 10
Итоговый остаток: 10

04 break и continue

Иногда цикл нужно прервать раньше срока или пропустить один круг. Для этого есть два слова.

• break — выйти из цикла совсем. Программа продолжается со строки после цикла.
• continue — пропустить остаток текущего круга и перейти к следующему.

for (let i = 1; i <= 10; i++) {
  if (i === 4) {
    console.log("Нашли нужную остановку! Выходим");
    break;
  }
  console.log(`Проезжаем остановку №${i}`);
}
console.log("Цикл закончился");

Остаток от деления: оператор %

Для примера с continue нам понадобится оператор % — остаток от деления. 7 % 3 — это остаток от деления 7 на 3, то есть 1. Число чётное, если остаток от деления на 2 равен нулю.

console.log(7 % 3);    // → 1   (7 = 3 + 3 + остаток 1)
console.log(10 % 5);   // → 0   (делится нацело)
console.log(9 % 2);    // → 1   (нечётное)
console.log(8 % 2);    // → 0   (чётное)

for (let i = 1; i <= 8; i++) {
  if (i % 2 === 0) {
    continue;           // чётные пропускаем
  }
  console.log(`Нечётное число: ${i}`);
}

Приём: while (true) и break

Бывает, что заранее непонятно, когда остановиться. Тогда пишут условие true (цикл «навсегда») и выходят через break, когда пришло время. Это единственный случай, когда «вечный» цикл — осознанный, потому что выход у него предусмотрен.

let n = 1;
while (true) {
  n *= 2;               // удваиваем
  console.log(n);
  if (n > 50) {
    break;              // выход предусмотрен
  }
}
console.log("Остановились на", n);

let i = 0;
while (i < 5) {
  if (i === 2) {
    continue;      // перескочили i++ — i навсегда останется равным 2
  }
  console.log(i);
  i++;
}

Решение: менять счётчик до continue или использовать for. Подробнее о бесконечных циклах — в разделе 08.

Читать подробнее: MDN — break · MDN — continue · learn.javascript.ru — break и continue

const wallet = 100;
const price = 15;
// for (let i = 1; i <= 10; i++) { ... }

Самбуса №1: всего 15 сомони
Самбуса №2: всего 30 сомони
Самбуса №3: всего 45 сомони
Самбуса №4: всего 60 сомони
Самбуса №5: всего 75 сомони
Самбуса №6: всего 90 сомони
Денег больше нет

for (let i = 1; i <= 10; i++) {
  // пропустите кратные трём
  console.log(i);
}

1
2
4
5
7
8
10

for (let i = 1; i <= 10; i++) {
  console.log(i);
  if (i = 5) {
    break;
  }
}

1
2
3
4
5

05 Перебор строки: for..of

Цикл можно запускать не только по числам, но и по буквам строки. Для этого есть удобная форма for..of («для каждого … из …»):

for (const letter of "Душанбе") {
  console.log(letter);
}

На каждом круге в переменную letter попадает следующая буква. Не нужно ни счётчика, ни условия, ни шага — JavaScript сам дойдёт до конца строки. Пишем const, потому что на каждом круге создаётся новая переменная, а внутри круга мы её не меняем.

Тот же перебор через обычный for

Каждая буква в строке имеет номер — индекс. Нумерация начинается с нуля. Получить букву по номеру можно через квадратные скобки: city[0]. Количество букв хранится в city.length. Поэтому последний индекс — length - 1.

const city = "Хорог";
console.log(city.length);   // → 5
console.log(city[0]);       // → Х
console.log(city[4]);       // → г

for (let i = 0; i < city.length; i++) {
  console.log(`${i}: ${city[i]}`);
}

Когда нужен только сам символ — берём for..of, это проще. Когда нужен ещё и номер (например, сравнить первую и последнюю букву) — берём обычный for с индексом.

Типичные задачи на строки

Посчитать, сколько раз встречается буква:

const word = "самбуса";
let count = 0;
for (const ch of word) {
  if (ch === "с") {
    count++;
  }
}
console.log(`Букв «с»: ${count}`);   // → Букв «с»: 2

Собрать новую строку — например, перевернуть слово. Каждую новую букву приписываем слева к уже собранному:

let reversed = "";
for (const ch of "оши") {
  reversed = ch + reversed;
  console.log(`взяли «${ch}» → ${reversed}`);
}
console.log(reversed);   // → ишо

А что с массивами? Маленький взгляд вперёд

Точно так же for..of умеет перебирать список значений — он называется массив и записывается в квадратных скобках. Массивам посвящён весь следующий урок, а пока просто посмотрите — форма цикла та же:

for (const dish of ["плов", "самбуса", "курутоб"]) {
  console.log(`В меню: ${dish}`);
}

const word = "Душанбе";
word[0] = "К";             // ✖ строку нельзя менять по символам

for (const digit of 12345) {   // ✖ число не перебирается
  console.log(digit);
}

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

const city = "Хуҷанд";
// for (const ... of ...)

Буква: Х
Буква: у
Буква: ҷ
Буква: а
Буква: н
Буква: д

const text = "Душанбе — столица Таджикистана";
// счётчик, цикл, вывод

Букв «а»: 5

const word = "MakeFirstStep";
// let result = "";

petStsriFekaM

const word = "Душанбе";
let isPalindrome = true;
// цикл for по индексам

console.log(`${word} — ${isPalindrome ? "палиндром" : "не палиндром"}`);

Душанбе — не палиндром

06 Счётчики и накопители

Почти любой цикл в реальной программе что-то накапливает: общую сумму чека, число подходящих товаров, самую высокую цену, итоговую строку. Для этого есть универсальный приём:

1. До цикла заводим переменную с начальным значением (накопитель).
2. В теле цикла обновляем её на каждом круге.
3. После цикла используем итог.

Сумма

let total = 0;                       // старт — пусто

for (let day = 1; day <= 5; day++) {
  total += day * 10;                 // в день N откладываем N × 10
  console.log(`День ${day}: +${day * 10}, всего ${total}`);
}

console.log(`Накоплено: ${total} сомони`);

Произведение

Для умножения старт — единица: ноль «съест» всё произведение. Факториал числа (4! = 1 · 2 · 3 · 4) — классика:

let product = 1;
for (let i = 1; i <= 4; i++) {
  product *= i;
}
console.log(`4! = ${product}`);   // → 4! = 24

Счётчик «сколько подходит»

let count = 0;
for (let n = 1; n <= 50; n++) {
  if (n % 7 === 0) {
    count++;
  }
}
console.log(`Чисел, кратных 7, до 50: ${count}`);   // → 7

Максимум и среднее

let best = 0;       // лучшая прибыль
let bestDay = 0;    // в какой день она была
let sum = 0;

for (let day = 1; day <= 9; day++) {
  const profit = day * (10 - day);   // условная формула прибыли
  sum += profit;
  if (profit > best) {
    best = profit;
    bestDay = day;
  }
}

console.log(`Лучший день: ${bestDay}, прибыль ${best}`);
console.log(`Среднее: ${sum / 9}`);

Строка

Накопителем может быть и строка. Во вложенных циклах (раздел 07) этот приём нам очень пригодится:

let line = "";
for (let i = 1; i <= 5; i++) {
  line += i + " ";
}
console.log(line);   // → 1 2 3 4 5

for (let i = 1; i <= 3; i++) {
  let total = 0;           // ← каждый круг начинаем с нуля!
  total += i;
  console.log(`total = ${total}`);   // 1, 2, 3 вместо 1, 3, 6
}

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

// let sum = 0;

Сумма: 55

// накопитель, цикл по дням 1..7, два вывода

Итого: 560 сомони
В среднем за день: 80 сомони

let result = 0;
for (let i = 1; i <= 5; i++) {
  result *= i;
}
console.log(`5! = ${result}`);

5! = 120

let balance = 1000;
let years = 0;
// пока balance меньше 2000

Вклад удвоится через 8 лет: 2144 сомони

07 Вложенные циклы

Внутри цикла может быть другой цикл. Это называется вложенными циклами. Они нужны везде, где есть «двойной» перебор: дни и пары в расписании, строки и столбцы в таблице, ряды и места в зале.

for (let day = 1; day <= 2; day++) {
  for (let lesson = 1; lesson <= 3; lesson++) {
    console.log(`День ${day}, пара ${lesson}`);
  }
}

Как это выполняется

1. Внешний цикл начинает круг: day = 1.
2. Внутренний цикл запускается с самого начала и проходит все свои круги: lesson = 1, 2, 3.
3. Внутренний закончился. Внешний делает шаг: day = 2.
4. Внутренний снова запускается с нуля и снова проходит все круги.

Всего тело внутреннего цикла выполнилось 2 × 3 = 6 раз. Правило: число выполнений тела = круги внешнего × круги внутреннего.

Рисуем фигуры

console.log всегда переводит строку, поэтому нарисовать ряд символов в одной строке напрямую нельзя. Решение — собрать всю строку в накопитель внутренним циклом, а вывести её после внутреннего цикла:

for (let row = 1; row <= 3; row++) {
  let line = "";                       // новая пустая строка для каждой строки
  for (let col = 1; col <= 5; col++) {
    line += "*";
  }
  console.log(line);                   // выводим готовую строку
}

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

for (let row = 1; row <= 4; row++) {
  let line = "";
  for (let col = 1; col <= row; col++) {
    line += "#";
  }
  console.log(line);
}

И, наконец, таблица умножения: в клетке стоит произведение номера строки и номера столбца.

for (let row = 1; row <= 3; row++) {
  let line = "";
  for (let col = 1; col <= 3; col++) {
    line += row * col + " ";
  }
  console.log(line);
}

for (let day = 1; day <= 3; day++) {
  for (let lesson = 1; lesson <= 3; lesson++) {
    if (day === 2 && lesson === 2) {
      break;            // прервали только пары второго дня
    }
    console.log(`День ${day}, пара ${lesson}`);
  }
}

// два вложенных цикла

####
####
####
####

// for по рядам, внутри for по местам

Ряд 1, место 1
Ряд 1, место 2
Ряд 1, место 3
Ряд 2, место 1
Ряд 2, место 2
Ряд 2, место 3

const symbol = "*";
const height = 5;

*
**
***
****
*****

let line = "";
for (let row = 1; row <= 3; row++) {
  for (let col = 1; col <= 3; col++) {
    line += "*";
  }
  console.log(line);
}

***
***
***

// строки и столбцы с нуля: 0..3

#.#.
.#.#
#.#.
.#.#

08 Бесконечный цикл: как не зависнуть

Цикл остановится, только если его условие когда-нибудь станет false. Если условие всегда истинно, цикл не закончится никогда. Это бесконечный цикл, и это самая известная ошибка начинающих (и не только) программистов. Страница с таким циклом «зависает»: кнопки не нажимаются, вкладка не отвечает.

Как это выглядит на нашей странице

Раннер на этой странице защищён: если код «молчит» дольше нескольких секунд, он принудительно останавливается и пишет красное сообщение. Нажмите ▶ Запустить и подождите примерно три секунды:

let i = 1;
while (i <= 5) {
  // забыли написать i++ — условие всегда true
}
console.log("Эта строка никогда не выполнится");

Вы увидите сообщение ⏱ Код выполняется слишком долго (возможен бесконечный цикл). Это страховка только нашей страницы. В обычной программе или на реальном сайте такой подстраховки нет, и всё просто зависнет.

Откуда берутся бесконечные циклы

Три вопроса перед запуском цикла

1. Что меняется на каждом круге? Должна меняться переменная из условия.
2. В какую сторону она меняется? К границе условия, а не от неё.
3. Может ли условие стать false? Подставьте 2–3 значения и проверьте руками.

Предохранитель: цикл, который не может зависнуть

Когда пишете цикл с нетривиальным условием, добавьте счётчик кругов и ограничьте его. Если что-то пойдёт не так — цикл сам выйдет, и вы увидите это в консоли, а не получите зависшую страницу:

let money = 18;
let rounds = 0;

while (money > 0) {
  rounds++;
  if (rounds > 100) {          // предохранитель
    console.log("Аварийная остановка: слишком много кругов");
    break;
  }
  money -= 6;                  // уменьшаем деньги на 6
}
console.log(`Кругов: ${rounds}, денег: ${money}`);

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

let lesson = 1;
let safety = 0;

while (lesson <= 3) {
  console.log(`Урок ${lesson}`);

  safety++;
  if (safety > 5) {
    console.log("Аварийная остановка");
    break;
  }
}

Урок 1
Урок 2
Урок 3

09 ИИ-блок: объяснить чужой код построчно

В работе вы почти никогда не пишете код с нуля: чаще читаете то, что написал коллега, нашли в интернете или выдал ИИ. Умение разобрать чужой цикл — один из главных навыков. ИИ здесь отличный помощник, если просить правильно: не «реши», а «объясни, как новичку».

Возьмём чужой код

Допустим, коллега прислал такую программу. Что она делает?

let total = 0;
for (let n = 1; n <= 10; n++) {
  if (n % 2 === 0) continue;
  total += n;
}
console.log(total);

Слабый и сильный запрос

Как проверить объяснение ИИ

ИИ может объяснять уверенно — и ошибаться. Поэтому ответ всегда проверяется по трём шагам:

1. Запустите код и запишите настоящий вывод в консоли.
2. Сравните с тем, что «сказал» ИИ. Не совпало — ИИ ошибся, верьте консоли.
3. Добавьте трассировку: console.log внутри цикла, который печатает счётчик и накопитель на каждом круге. Так вы видите весь путь, а не только результат.

Ещё два шаблона для тренировки

Из библиотеки промптов курса: попросить объяснить построчно без переписывания и попросить задачи без готовых решений.

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

Типичные ошибки ИИ при объяснении циклов

let total = 0;
for (let n = 1; n <= 10; n++) {
  if (n % 2 === 0) continue;
  total += n;
  // добавьте трассировку здесь
}
console.log(total);

n=1, total=1
n=3, total=4
n=5, total=9
n=7, total=16
n=9, total=25
25

10 Практика на уроке: четыре классические задачи

FizzBuzz, таблица умножения, простые числа и пирамида — программы, которые просят на собеседованиях и которыми учатся все начинающие программисты в мире. Идём по порядку, у каждой — разбор и затем задача с проверкой. Набирайте код сами, не копируйте.

1. FizzBuzz

Условие: выведите числа от 1 до 15. Но если число делится на 3 — вместо него слово Fizz, если на 5 — Buzz, если сразу и на 3, и на 5 — FizzBuzz.

План: цикл по числам, внутри цепочка if / else if / else. Самая частая ловушка — порядок проверок. Посмотрите, что получится, если проверить «на 3» первым:

for (let i = 1; i <= 15; i++) {
  if (i % 3 === 0) {
    console.log("Fizz");
  } else if (i % 5 === 0) {
    console.log("Buzz");
  } else if (i % 15 === 0) {
    console.log("FizzBuzz");   // до этой ветки дело не дойдёт
  } else {
    console.log(i);
  }
}

Общее правило цепочки if / else if: самое узкое условие — первым. Число, делящееся и на 3, и на 5, — самый редкий случай.

for (let i = 1; i <= 15; i++) {
  // цепочка if / else if / else
}

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

2. Таблица умножения

Условие: таблица умножения 9 × 9: в каждой строке — произведения номера строки на числа от 1 до 9. Это уже знакомый нам двойной цикл со строкой-накопителем:

for (let row = 1; row <= 3; row++) {
  let line = "";
  for (let col = 1; col <= 3; col++) {
    line += row * col + " ";
  }
  console.log(line);
}

for (let row = 1; row <= 3; row++) {
  let line = "";
  for (let col = 1; col <= 3; col++) {
    line += row * col + " ";
  }
  console.log(line);
}

1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81

3. Простые числа

Условие: найти все простые числа до 30. Простое число делится только на 1 и на само себя (2, 3, 5, 7, 11…). Единица простой не считается.

План: сначала научимся проверять одно число. Пробуем делители d от 2 до n - 1. Нашёлся делитель — число составное, дальше проверять незачем (break). Результат держим в «флажке» — переменной true / false:

const n = 29;
let isPrime = true;                 // пока считаем простым

for (let d = 2; d < n; d++) {
  if (n % d === 0) {                // нашли делитель
    isPrime = false;
    break;
  }
}

console.log(`${n} — ${isPrime ? "простое" : "составное"}`);

Попробуйте n = 21 и n = 2. Теперь оберните проверку во внешний цикл по n от 2 до 30 и собирайте простые числа в строку-накопитель.

let primes = "";
// внешний цикл по n, внутренний по делителям d

console.log("Простые числа до 30: " + primes);

Простые числа до 30: 2 3 5 7 11 13 17 19 23 29

4. Пирамида из символов

Условие: нарисовать пирамиду высотой 5. В строке номер row нужно (height − row) пробелов слева и (2·row − 1) символов. Для первой строки это 4 пробела и 1 звезда, для последней — 0 пробелов и 9 звёзд.

1. Внешний цикл по строкам: row от 1 до height.
2. Первый внутренний цикл добавляет в строку пробелы.
3. Второй внутренний цикл добавляет символы.
4. Готовую строку выводим после обоих внутренних циклов.

const symbol = "*";
const height = 5;

for (let row = 1; row <= height; row++) {
  let line = "";
  // пробелы
  // символы
  console.log(line);
}

    *
   ***
  *****
 *******
*********

11 Домашнее задание: loops.js

Результат домашней работы — один файл loops.js с решениями восьми задач и отдельный файл explain.md с разбором чужого решения вместе с ИИ. Задачи решаются только тем, что мы прошли: переменные, условия, for, while, for..of, break, continue. Функций и массивов нет.

8 задач

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

1. Таблица на 7. Выведите таблицу умножения на 7 от 1 до 10: 7 × 1 = 7, … , 7 × 10 = 70.
2. Чётные числа. Найдите сумму всех чётных чисел от 1 до 100. Ответ — 2550.
3. Обратный отсчёт. Выведите числа от 10 до 1, но число 5 пропустите (continue), а после цикла выведите «Пуск!».
4. Факториалы. Для каждого n от 1 до 10 выведите строку n! = … (вложенный цикл не нужен: накопитель можно обновлять прямо во внешнем цикле). Последняя строка: 10! = 3628800.
5. Гласные. Посчитайте гласные в строке "ассалому алейкум" (а, е, о, у). Ответ — 7. Проверка «буква гласная» — через цепочку ||.
6. Фибоначчи. Выведите первые 12 чисел Фибоначчи (каждое следующее — сумма двух предыдущих): 1 1 2 3 5 8 13 21 34 55 89 144. Нужны две переменные «предыдущее» и «текущее».
7. Сумма цифр. Найдите сумму цифр числа 98765. Подсказка: n % 10 — последняя цифра, Math.floor(n / 10) — число без неё. Ответ — 35.
8. Ёлочка-ромб. Нарисуйте ромб высотой 7 из символа *: верх — пирамида из практики (4 строки), низ — перевёрнутая (3 строки). Ширина самой широкой строки — 7.

Разбор чужого решения с ИИ

Вот решение, которое «нашли в интернете». Оно считает сумму всех чисел от 1 до 100, кратных 3 или 5. Запустите его:

let sum = 0;
for (let i = 1; i <= 100; i++) {
  if (i % 3 !== 0 && i % 5 !== 0) continue;
  sum += i;
}
console.log(sum);

1. Потратьте 15 минут: выпишите в тетрадь, что делает каждая строка и почему условие записано через !== и &&.
2. Дайте код ИИ по сильному шаблону из раздела 09 (формула «объясни как новичку»). Сохраните свой промпт.
3. Сравните ответ с настоящим выводом (2418) и со своими записями. Добавьте трассировку console.log и покажите хотя бы три круга.
4. Перепишите условие так, чтобы оно читалось проще, без continue: if (i % 3 === 0 || i % 5 === 0) { sum += i; }. Убедитесь, что результат тот же.
5. В explain.md напишите: (а) свой промпт; (б) что ИИ объяснил верно; (в) что ИИ упустил или написал неточно; (г) что вы бы не взяли из его ответа и почему.

Что сдать

• Файл loops.js с восемью задачами. Каждая выводит результат в консоль.
• Файл explain.md с разбором (пункты а–г). Минимум 8 содержательных строк, без копирования ответа ИИ целиком.
• Ссылка на GitHub-репозиторий или архив в Telegram-группу.

Как оценим (0–10)

Бонус (без баллов): шахматная доска 8 × 8, числа-палиндромы от 100 до 200, треугольник Паскаля.