Классический цикл for: всё в одном месте

Цикл for — это самый популярный цикл в JavaScript. Если while — это «делай пока не скажу стоп», то for — это «сделай ровно столько-то раз». Все три ключевых элемента: начало, условие и шаг — живут прямо в заголовке. Компактно, читаемо, удобно.

🔍 Анатомия цикла for

Вспомните цикл while из прошлого урока. Чтобы посчитать от 1 до 5, нам нужно было написать три отдельных вещи: объявить счётчик до цикла, написать условие в заголовке, и обновить счётчик внутри тела. Эти три части разбросаны по коду, и легко что-то забыть.

Цикл for решает эту проблему, собирая все три части в одну строку — заголовок:

for (инициализация; условие; шаг) {
  // тело цикла
}

Давайте сразу посмотрим на пример и разберём каждую часть:

for (let i = 1; i <= 5; i++) {
  console.log(i);
}
// Результат: 1 2 3 4 5

Смотрим на три части заголовка через точку с запятой:

Порядок выполнения шаг за шагом:

1. Инициализация: let i = 1 — выполняется один раз
2. Условие: i <= 5 → true → заходим в тело
3. Тело: console.log(1)
4. Шаг: i++ → i = 2
5. Условие: 2 <= 5 → true → тело → шаг → ...
6. Когда i = 6: условие 6 <= 5 → false → выход

⚖️ for vs while: что выбрать?

Технически for и while взаимозаменяемы — всё, что можно написать через for, можно написать через while и наоборот. Но у каждого есть своя область применения:

// Ровно 10 раз
for (let i = 0; i < 10; i++) {
  console.log(i);
}

// Перебираем массив
for (let i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

// Пока не нашли нужное
while (!found) {
  // ищем...
}

// Пока файл не прочитан
while (reader.hasMore()) {
  reader.readLine();
}

📦 Перебор массива по индексу

Один из самых частых случаев применения for — перебор массива. В JavaScript массив — это упорядоченный список значений. Каждый элемент имеет индекс — порядковый номер, начиная с нуля.

const fruits = ["яблоко", "банан", "вишня", "манго"];
//              индекс: 0         1        2         3

console.log(fruits[0]); // "яблоко"
console.log(fruits[2]); // "вишня"
console.log(fruits.length); // 4 — количество элементов

Чтобы перебрать все элементы массива, нам нужно пройти по индексам от 0 до length - 1. Цикл for идеально подходит для этого:

const fruits = ["яблоко", "банан", "вишня", "манго"];

for (let i = 0; i < fruits.length; i++) {
  console.log(i, ":", fruits[i]);
}

// Результат:
// 0 : яблоко
// 1 : банан
// 2 : вишня
// 3 : манго

Обратите внимание: условие i < fruits.length, а не i <= fruits.length. Последний индекс равен length - 1, поэтому используем строгое «меньше». Ошибка здесь — одна из самых распространённых: написать <= и получить undefined на последней итерации.

Пример: найдём максимальное число в массиве:

const numbers = [3, 17, 8, 42, 5, 11];
let max = numbers[0]; // начинаем с первого элемента

for (let i = 1; i < numbers.length; i++) {
  if (numbers[i] > max) {
    max = numbers[i]; // нашли больше — обновляем максимум
  }
}

console.log("Максимум:", max); // 42

Логика: берём первый элемент как «пока лучший максимум», потом сравниваем каждый следующий. Если нашли больше — обновляем. В конце max содержит наибольшее значение.

⏪ Обратный цикл: от N до 0

Цикл for может идти не только вперёд, но и назад — достаточно изменить инициализацию, условие и шаг. Например, обратный отсчёт:

// Обратный отсчёт от 5 до 1
for (let i = 5; i >= 1; i--) {
  console.log(i);
}
console.log("Пуск!");

// Результат:
// 5
// 4
// 3
// 2
// 1
// Пуск!

Три изменения по сравнению с обычным циклом:

• Инициализация: i = 5 — начинаем с конца
• Условие: i >= 1 — продолжаем, пока не дошли до нуля
• Шаг: i-- — уменьшаем (а не увеличиваем) на каждом шаге

Обратный перебор массива тоже полезен — например, когда нужно вывести элементы в обратном порядке:

const steps = ["готово", "тестирование", "разработка", "планирование"];

for (let i = steps.length - 1; i >= 0; i--) {
  console.log((steps.length - i) + ". " + steps[i]);
}
// 1. планирование
// 2. разработка
// 3. тестирование
// 4. готово

🔧 Шаг может быть любым

Мы не обязаны увеличивать счётчик на 1. Шаг — это любое выражение, которое меняет счётчик. Например, можно перебирать только чётные числа, или прыгать сразу на 5:

// Только чётные числа от 0 до 10
for (let i = 0; i <= 10; i += 2) {
  console.log(i); // 0 2 4 6 8 10
}

// Каждые 5 единиц
for (let i = 0; i <= 25; i += 5) {
  console.log(i); // 0 5 10 15 20 25
}

// Удвоение: 1, 2, 4, 8, 16, 32...
for (let i = 1; i <= 100; i *= 2) {
  console.log(i); // 1 2 4 8 16 32 64
}

Пример: найдём сумму чисел от 1 до N используя for:

function sumToN(n) {
  let sum = 0;
  for (let i = 1; i <= n; i++) {
    sum += i;
  }
  return sum;
}

console.log(sumToN(10));  // 55
console.log(sumToN(100)); // 5050

🪆 Вложенные for: цикл внутри цикла

Внутри тела цикла можно написать ещё один цикл. Это называется вложенным циклом. Классический пример — таблица умножения. Для каждого числа строки нам нужно пройти по всем числам столбца:

// Таблица умножения 3×3
for (let i = 1; i <= 3; i++) {       // внешний цикл: строки
  for (let j = 1; j <= 3; j++) {     // внутренний цикл: столбцы
    console.log(i + " × " + j + " = " + (i * j));
  }
}

// Результат:
// 1 × 1 = 1
// 1 × 2 = 2
// 1 × 3 = 3
// 2 × 1 = 2
// 2 × 2 = 4
// 2 × 3 = 6
// 3 × 1 = 3
// 3 × 2 = 6
// 3 × 3 = 9

Как это работает: внешний цикл устанавливает i = 1, а внутренний пробегает j от 1 до 3. Потом внешний устанавливает i = 2, и внутренний снова пробегает весь свой диапазон. И так далее.

Подробнее вложенные циклы разберём в уроке 4.4. Пока запомните главное: вложенные циклы умножают количество итераций — если внешний делает 3 шага, а внутренний 3 шага, то всего будет 3 × 3 = 9 операций.

✅ Итоги урока

• Цикл for — самый удобный для случаев, когда число итераций известно заранее
• Три части заголовка: инициализация (один раз), условие (перед каждой итерацией), шаг (после каждой итерации)
• Перебор массива: for (let i = 0; i < arr.length; i++) — индексы от 0 до length-1
• Обратный цикл: начать с большого числа, уменьшать счётчик (i--), условие с >=
• Шаг может быть любым: i += 2, i *= 2, не только i++
• Вложенные циклы: цикл внутри цикла, итерации перемножаются (N × M)
• Используй for для счётных задач, while для задач с нечётким условием остановки