break и continue: управление циклом

break — это «хватит». Он немедленно прекращает цикл, внутри которого стоит, и управление уходит на первую строку после цикла. Всё, что осталось в теле итерации ниже break, не выполняется — ни одной строки.

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

const nums = [4, 9, 15, 22, 7];
let found = null;
for (const n of nums) {
  if (n > 10) { found = n; break; }
}
console.log(found);

Второе по частоте применение — цикл, у которого условие выхода живёт не в заголовке, а посередине тела. Тогда заголовок пишут заведомо бесконечным (while (true)), а выход отдают break. Это законный приём, а не признак плохого кода — главное, чтобы выход существовал.

let n = 1;
while (true) {
  n = n * 3;
  if (n > 50) break;
}
console.log(n);

continue не выходит из цикла, а обрывает только текущую итерацию: остаток тела пропускается, и работа продолжается со следующего круга. Для for «следующий круг» означает сначала шаг (i++), потом проверку условия — счётчик не застревает.

const words = ["код", "", "цикл", "", "шаг"];
let joined = "";
for (const w of words) {
  if (w === "") continue;
  joined += w + " ";
}
console.log(joined.trim());

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

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

let i = 0;
let odd = 0;
while (i < 5) {
  i++; // шаг делаем ДО continue, иначе цикл зависнет
  if (i % 2 === 0) continue;
  odd++;
}
console.log(odd);

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

const grid = [[1, 2], [3, 7], [4, 5]];
let hit = null;
outer: for (const row of grid) {
  for (const cell of row) {
    if (cell === 7) { hit = cell; break outer; }
  }
}
console.log(hit);

continue с меткой работает так же адресно: он завершает текущую итерацию помеченного цикла и переводит именно его на следующий шаг. Внутренний цикл при этом просто заканчивается досрочно.

let pairs = 0;
rows: for (let i = 1; i <= 3; i++) {
  for (let j = 1; j <= 3; j++) {
    if (j === 2) continue rows;
    pairs++;
  }
}
console.log(pairs);

const log = [];
skip: {
  log.push("до");
  break skip;
  log.push("после");
}
console.log(log);

Ранний выход — это приём, а не просто оператор: к цепочке if мы прикладывали его в статье «Условия: if, else и тернарный оператор», а внутри цикла ту же работу делает continue. Вместо того чтобы вкладывать условия одно в другое и уводить полезный код на четвёртый уровень отступа, сначала отсеивают всё лишнее короткими continue, а главное действие оставляют на ровном месте — его видно сразу.

const users = [{ name: "Ада", age: 36 }, { name: "", age: 40 }, { name: "Ким", age: 15 }];
const ok = [];
for (const u of users) {
  if (!u.name) continue;
  if (u.age < 18) continue;
  ok.push(u.name);
}
console.log(ok);

Внутри функции ту же работу делает return: он и цикл прерывает, и функцию завершает, сразу отдавая результат. Поэтому связка «break плюс переменная-флаг плюс проверка после цикла» почти всегда разворачивается в одну строку.

function indexOfValue(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) return i;
  }
  return -1;
}
console.log(indexOfValue(["a", "b", "c"], "b"));

Метки в живом коде — редкость. Потянулись за меткой — сначала прикиньте, не проще ли вынести внутренний цикл в функцию и выйти через return.

Сначала общая картина: чем именно отличаются четыре способа прервать ход цикла.

Первая ловушка — switch внутри цикла. Его собственный break закрывает switch, а не цикл: перебор пойдёт дальше как ни в чём не бывало. Чтобы выйти из цикла из ветки case, нужна метка.

let stop = "";
loop: for (const cmd of ["go", "wait", "quit", "go"]) {
  switch (cmd) {
    case "quit": stop = cmd; break loop;
  }
}
console.log(stop);

Вторая ловушка — методы массивов. Массив умеет перебирать себя сам: forEach и map получают функцию — отдельный кусок кода — и вызывают её для каждого элемента. Цикл при этом спрятан внутри метода, а в вашем коде его нет, поэтому ни break, ни continue в теле такой функции не работают: прервать из неё чужой перебор нельзя. Подробно эти методы разбирает статья «Методы массивов: map, filter, reduce». Выхода из ловушки два: вернуться к for...of или взять метод, который сам умеет останавливаться, — например, find, с которым знакомит статья «Поиск и сортировка». И помните, что break и continue — инструкции, а не значения: в тернарный оператор или в правую часть присваивания их не поставить.

const nums = [1, 2, 3, 4];
console.log(nums.find((n) => n > 2));
console.log(nums.some((n) => n > 3));
console.log(nums.every((n) => n > 0));