Циклы while и for
При написании скриптов зачастую встаёт задача сделать однотипное действие много раз.
Например, вывести товары из списка один за другим. Или просто перебрать все числа от 1 до 10 и для каждого выполнить одинаковый код.
Для многократного повторения одного участка кода предусмотрены циклы.
Циклы for…of и for…in
Небольшое объявление для продвинутых читателей.
В этой статье рассматриваются только базовые циклы: while , do..while и for(..;..;..) .
Если вы пришли к этой статье в поисках других типов циклов, вот указатели:
- См. for…in для перебора свойств объекта.
- См. for…of и Перебираемые объекты для перебора массивов и перебираемых объектов.
В противном случае, продолжайте читать.
Цикл «while»
Цикл while имеет следующий синтаксис:
while (condition) < // код // также называемый "телом цикла" >Код из тела цикла выполняется, пока условие condition истинно.
Например, цикл ниже выводит i , пока i < 3 :
let i = 0; while (i < 3) < // выводит 0, затем 1, затем 2 alert( i ); i++; >Одно выполнение тела цикла по-научному называется итерация. Цикл в примере выше совершает три итерации.
Если бы строка i++ отсутствовала в примере выше, то цикл бы повторялся (в теории) вечно. На практике, конечно, браузер не позволит такому случиться, он предоставит пользователю возможность остановить «подвисший» скрипт, а JavaScript на стороне сервера придётся «убить» процесс.
Любое выражение или переменная может быть условием цикла, а не только сравнение: условие while вычисляется и преобразуется в логическое значение.
Например, while (i) – более краткий вариант while (i != 0) :
let i = 3; while (i) < // когда i будет равно 0, условие станет ложным, и цикл остановится alert( i ); i--; >Фигурные скобки не требуются для тела цикла из одной строки
Если тело цикла состоит лишь из одной инструкции, мы можем опустить фигурные скобки :
let i = 3; while (i) alert(i--);Цикл «do…while»
Проверку условия можно разместить под телом цикла, используя специальный синтаксис do..while :
do < // тело цикла >while (condition);Цикл сначала выполнит тело, а затем проверит условие condition , и пока его значение равно true , он будет выполняться снова и снова.
let i = 0; do < alert( i ); i++; >while (i < 3);Такая форма синтаксиса оправдана, если вы хотите, чтобы тело цикла выполнилось хотя бы один раз, даже если условие окажется ложным. На практике чаще используется форма с предусловием: while(…) .
Цикл «for»
Более сложный, но при этом самый распространённый цикл — цикл for .
Выглядит он так:
for (начало; условие; шаг) < // . тело цикла . >Давайте разберёмся, что означает каждая часть, на примере. Цикл ниже выполняет alert(i) для i от 0 до (но не включая) 3 :
for (let i = 0; i < 3; i++) < // выведет 0, затем 1, затем 2 alert(i); >Рассмотрим конструкцию for подробней:
| часть | ||
|---|---|---|
| начало | let i = 0 | Выполняется один раз при входе в цикл |
| условие | i < 3 | Проверяется перед каждой итерацией цикла. Если оно вычислится в false , цикл остановится. |
| тело | alert(i) | Выполняется снова и снова, пока условие вычисляется в true . |
| шаг | i++ | Выполняется после тела цикла на каждой итерации перед проверкой условия. |
В целом, алгоритм работы цикла выглядит следующим образом:
Выполнить начало → (Если условие == true → Выполнить тело, Выполнить шаг) → (Если условие == true → Выполнить тело, Выполнить шаг) → (Если условие == true → Выполнить тело, Выполнить шаг) → . То есть, начало выполняется один раз, а затем каждая итерация заключается в проверке условия , после которой выполняется тело и шаг .
Если тема циклов для вас нова, может быть полезным вернуться к примеру выше и воспроизвести его работу на листе бумаги, шаг за шагом.
Вот в точности то, что происходит в нашем случае:
// for (let i = 0; i < 3; i++) alert(i) // Выполнить начало let i = 0; // Если условие == true → Выполнить тело, Выполнить шаг if (i < 3) < alert(i); i++ >// Если условие == true → Выполнить тело, Выполнить шаг if (i < 3) < alert(i); i++ >// Если условие == true → Выполнить тело, Выполнить шаг if (i < 3) < alert(i); i++ >// . конец, потому что теперь i == 3Встроенное объявление переменной
В примере переменная счётчика i была объявлена прямо в цикле. Это так называемое «встроенное» объявление переменной. Такие переменные существуют только внутри цикла.
for (let i = 0; i < 3; i++) < alert(i); // 0, 1, 2 >alert(i); // ошибка, нет такой переменнойВместо объявления новой переменной мы можем использовать уже существующую:
let i = 0; for (i = 0; i < 3; i++) < // используем существующую переменную alert(i); // 0, 1, 2 >alert(i); // 3, переменная доступна, т.к. была объявлена снаружи циклаПропуск частей «for»
Любая часть for может быть пропущена.
Для примера, мы можем пропустить начало если нам ничего не нужно делать перед стартом цикла.
let i = 0; // мы уже имеем объявленную i с присвоенным значением for (; i < 3; i++) < // нет необходимости в "начале" alert( i ); // 0, 1, 2 >Можно убрать и шаг :
let i = 0; for (; i
Это сделает цикл аналогичным while (i < 3) .
А можно и вообще убрать всё, получив бесконечный цикл:
При этом сами точки с запятой ; обязательно должны присутствовать, иначе будет ошибка синтаксиса.
Прерывание цикла: «break»
Обычно цикл завершается при вычислении условия в false .
Но мы можем выйти из цикла в любой момент с помощью специальной директивы break .
Например, следующий код подсчитывает сумму вводимых чисел до тех пор, пока посетитель их вводит, а затем – выдаёт:
let sum = 0; while (true) < let value = +prompt("Введите число", ''); if (!value) break; // (*) sum += value; >alert( 'Сумма: ' + sum );Директива break в строке (*) полностью прекращает выполнение цикла и передаёт управление на строку за его телом, то есть на alert .
Вообще, сочетание «бесконечный цикл + break » – отличная штука для тех ситуаций, когда условие, по которому нужно прерваться, находится не в начале или конце цикла, а посередине или даже в нескольких местах его тела.
Переход к следующей итерации: continue
Директива continue – «облегчённая версия» break . При её выполнении цикл не прерывается, а переходит к следующей итерации (если условие все ещё равно true ).
Её используют, если понятно, что на текущем повторе цикла делать больше нечего.
Например, цикл ниже использует continue , чтобы выводить только нечётные значения:
for (let i = 0; i < 10; i++) < // если true, пропустить оставшуюся часть тела цикла if (i % 2 == 0) continue; alert(i); // 1, затем 3, 5, 7, 9 >Для чётных значений i , директива continue прекращает выполнение тела цикла и передаёт управление на следующую итерацию for (со следующим числом). Таким образом alert вызывается только для нечётных значений.
Директива continue позволяет избегать вложенности
Цикл, который обрабатывает только нечётные значения, мог бы выглядеть так:
for (let i = 0; i < 10; i++) < if (i % 2) < alert( i ); >>С технической точки зрения он полностью идентичен. Действительно, вместо continue можно просто завернуть действия в блок if .
Однако мы получили дополнительный уровень вложенности фигурных скобок. Если код внутри if более длинный, то это ухудшает читаемость, в отличие от варианта с continue .
Нельзя использовать break/continue справа от оператора „?“
Обратите внимание, что эти синтаксические конструкции не являются выражениями и не могут быть использованы с тернарным оператором ? . В частности, использование таких директив, как break/continue , вызовет ошибку.
Например, если мы возьмём этот код:
if (i > 5) < alert(i); >else
…и перепишем его, используя вопросительный знак:
(i > 5) ? alert(i) : continue; // continue здесь приведёт к ошибке…то будет синтаксическая ошибка.
Это ещё один повод не использовать оператор вопросительного знака ? вместо if .
Метки для break/continue
Бывает, нужно выйти одновременно из нескольких уровней цикла сразу.
Например, в коде ниже мы проходимся циклами по i и j , запрашивая с помощью prompt координаты (i, j) с (0,0) до (2,2) :
for (let i = 0; i < 3; i++) < for (let j = 0; j < 3; j++) < let input = prompt(`Значение на координатах ($,$)`, ''); // Что если мы захотим перейти к Готово (ниже) прямо отсюда? > > alert('Готово!');Нам нужен способ остановить выполнение, если пользователь отменит ввод.
Обычный break после input лишь прервёт внутренний цикл, но этого недостаточно. Достичь желаемого поведения можно с помощью меток.
Метка имеет вид идентификатора с двоеточием перед циклом:
labelName: for (. )
Вызов break в цикле ниже ищет ближайший внешний цикл с такой меткой и переходит в его конец.
outer: for (let i = 0; i < 3; i++) < for (let j = 0; j < 3; j++) < let input = prompt(`Значение на координатах ($,$)`, ''); // если пустая строка или Отмена, то выйти из обоих циклов if (!input) break outer; // (*) // сделать что-нибудь со значениями. > > alert('Готово!');В примере выше это означает, что вызовом break outer будет разорван внешний цикл до метки с именем outer .
Таким образом управление перейдёт со строки, помеченной (*) , к alert('Готово!') .
Можно размещать метку на отдельной строке:
outer: for (let i = 0; i
Директива continue также может быть использована с меткой. В этом случае управление перейдёт на следующую итерацию цикла с меткой.
Метки не позволяют «прыгнуть» куда угодно
Метки не дают возможности передавать управление в произвольное место кода.
Например, нет возможности сделать следующее:
break label; // не прыгает к метке ниже label: for (. )Директива break должна находиться внутри блока кода. Технически, подойдет любой маркированный блок кода, например:
label: < // . break label; // работает // . >…Хотя в 99.9% случаев break используется внутри циклов, как мы видели в примерах выше.
К слову, continue возможно только внутри цикла.
Итого
Мы рассмотрели 3 вида циклов:
- while – Проверяет условие перед каждой итерацией.
- do..while – Проверяет условие после каждой итерации.
- for (;;) – Проверяет условие перед каждой итерацией, есть возможность задать дополнительные настройки.
Чтобы организовать бесконечный цикл, используют конструкцию while (true) . При этом он, как и любой другой цикл, может быть прерван директивой break .
Если на данной итерации цикла делать больше ничего не надо, но полностью прекращать цикл не следует – используют директиву continue .
Обе этих директивы поддерживают метки, которые ставятся перед циклом. Метки – единственный способ для break/continue выйти за пределы текущего цикла, повлиять на выполнение внешнего.
Заметим, что метки не позволяют прыгнуть в произвольное место кода, в JavaScript нет такой возможности.
Цикл for и изменение переменных — Введение в программирование
Этот урок будет быстрым и простым, так что пристегнитесь.
Вызовем функцию факториала с циклом while:
const factorial = (n) => let counter = 1; let result = 1; while (counter n) result = result * counter; counter = counter + 1; > return result; > Когда мы работаем с переменными, мы часто поступаем так: меняем их значения, прибавляя к ним сколько-нибудь или умножая их на что-то. Или просто прибавляем или вычитаем единицу.
Как и во многих других языках программирования в JavaScript есть для этого упрощенные формы.
Вместо result = result * counter вы можете сказать result *= counter . Результат будет тот же самый, это просто способ сократить запись. Точно так же вы можете поступить со знаками плюс, минус и остатком от деления:
Добавление единицы к переменной — тоже очень типичная операция, поэтому вместо counter = counter + 1 можно записать counter++ . Так же для минуса — counter = counter - 1 равносильно counter-- . Это операторы инкрементирования и декрементирования.
Есть два вида, проще их понять на примере:
// Postfix let a = 3; let b; b = a++; // b = 3, a = 4 // Prefix let a = 3; let b; b = ++a; // b = 4, a = 4 Если вы поставите ++ после имени переменной — это постфиксная нотация — то фактическое сложение произойдёт после того, как значение вернётся. Вот почему b тут 3: оно получает значение перед тем как меняется a .
Если вы поставите ++ перед именем переменной — это префиксная нотация — то фактическое сложение произойдёт перед тем, как значение вернётся. Вот почему b тут 4: оно получает значение после того как меняется a .
Но в конце в обоих случаях a становится 4.
Это обновлённая функция факториала:
const factorial = (n) => let counter = 1; let result = 1; while (counter n) result *= counter; counter++; > return result; > Здесь не имеет значения, используем мы префикс или постфикс когда инкрементируем counter , потому что значение не хранится больше нигде.
Этот код немного проще и короче. Иметь цикл — этот повторяющийся код — со счётчиком контролирующим повторения — распространённый в программировании приём. Поэтому кроме цикла while существует цикл for. В нем есть встроенные счетчики.
Это та же функция факториала, но с циклом for вместо цикла while:
const factorial = (n) => let result = 1; for (let counter = 1; counter n; counter++) result *= counter; > return result; > Здесь три момента:
- Инициализация счётчика.
- Условие цикла. Так же как и в цикле while, этот цикл будет повторяться пока это условие истинно.
- Обновление счётчика. Как менять счётчик в каждом шаге.
А затем следует тело, код, который должен повторяться. Нам не нужно менять счётчик в теле, потому что он будет меняться, благодаря этому выражению сверху.
Пришло время использовать все эти навороченные знания и написать код! Переходите к тесту и упражнению прямо сейчас!
Дополнение к уроку
Скрытые сложности
Операции декремента и инкремента кажутся мощными механизмами, но их использование привносит ненужную сложность в программы. Код, написанный с их использованием, часто превращается в ребус. Попробуйте ответить, чему равно значение:
let x = 5; let y = 10; console.log(x++ + ++y); Как видите, этот код заставляет думать, так как кроме арифметических выражений, мы имеем дело с побочными эффектами.
Во многих языках таких операций нет в принципе. Линтеры (программы, проверяющие код на соответствие стандартам) в JS настроены так, чтобы "ругаться" при виде этих операций в коде. Вместо них предлагается делать так:
x += 1; // x = x + 1; Что гораздо проще и понятнее. Да, не получится записать выражение в одну строку, но сам код будет очевидным и без сюрпризов.
Соответствующее правило в eslint: https://eslint.org/docs/rules/no-plusplus
Switch
Конструкция switch может заменить собой несколько условий if . Вот пример обычного условия с if :
let answer; if (num === 1) answer = "One"; > else if (num === 2) answer = "Two"; > else answer = "Nothing"; > А вот как его можно переписать с помощью switch :
switch(num) case 1: // if (num === 1) answer = "One"; break; case 2: // if (num === 2) answer = "Two"; break; default: answer = "Nothing"; break; > break необходим, чтобы выйти из блока switch . Если break отсутствует, то выполнение пойдёт ниже по следующим случаям, игнорируя проверки. break также можно использовать в циклах for для мгновенного выхода из цикла.
Если в примере выше убрать все break 'и, а num будет равен 1, то выполнятся все строки:
answer = "One"; answer = "Two"; answer = "Nothing"; Так что в итоге answer будет иметь значение "Nothing".
Несколько значений case можно группировать.
switch(num) case 1: // if (num === 1) answer = "One"; break; case 2: // if (num === 2) case 3: // if (num === 3) case 4: // if (num === 4) answer = "Two to four"; break; default: answer = "Nothing"; break; > Выводы
Операторы инкрементирования и декрементирования:
// Postfix let a = 3; let b; b = a++; // b = 3, a = 4 // Prefix let a = 3; let b; b = ++a; // b = 4, a = 4 const factorial = (n) => let result = 1; // initialization↓ condition↓ update↓ for (let counter = 1; counter n; counter++) result *= counter; > return result; > Тут следует упомянуть о том, что все 3 выражения в цикле for не обязательны.
Например, в блоке инициализации не требуется определять переменные:
let counter = 1; for (; counter n; counter++) // любой код > Как и блок инициализации, блок условия не обязателен. Если пропустите это выражение, вы должны быть уверены, что прервете цикл где-то в теле, а не создадите бесконечный цикл.
for (let counter = 1;; counter++) if (counter n) break; // любой код > Вы можете пропустить все 3 блока. Снова убедитесь, что используете break, чтоб закончить цикл, а также изменить счётчик так, чтоб условие для break было истинно в нужный момент.
let counter = 1; for (;;) if (counter >= n) break; // любой код counter++; > Обратите внимание на то, что если внутри тела цикла использовать оператор return , то выполнение цикла будет прервано и функция вернет значение.
// Функция должна посчитать сумму всех чисел от 1 до n const sum = (n) => let result = 0; for (let counter = 1; counter n; counter++) return 10; // return прерывает цикл result += counter; > return result; > sum(5); // 10 sum(20); // 10 sum(50); // 10 
Остались вопросы? Задайте их в разделе «Обсуждение»
Вам ответят команда поддержки Хекслета или другие студенты
Об обучении на Хекслете
- Статья «Как учиться и справляться с негативными мыслями»
- Статья «Ловушки обучения»
- Статья «Сложные простые задачи по программированию»
- Урок «Как эффективно учиться на Хекслете»
- Вебинар « Как самостоятельно учиться »
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях:
Циклы в Java – как создать и прервать
Как в Java создавать циклы и управлять ими. Как с их помощью автоматизировать обработку массивов и генерацию объектов.
09 октября 2017 3 минуты 91761
Автор статьи
Мария Лисянская
Автор статьи
Мария Лисянская
https://gbcdn.mrgcdn.ru/uploads/post/1238/og_cover_image/ed12996e6ef61b13a868df82b32b1e6c
Цикл — это блок команд, который выполняется снова и снова, пока соблюдается определённое условие. Повторяемый фрагмент кода называют «телом цикла». Одно выполнение тела цикла называют итерацией.
В Яве можно работать с циклами нескольких типов - для этого есть следующие операторы:
while – цикл с предусловием – сначала проверяем условие, затем выполняем тело цикла;
do… while – цикл с постусловием – сначала выполняем один раз тело цикла, затем проверяем условие и, если оно соблюдается, продолжаем;
for – цикл со счётчиком – выполняется и при каждой итерации обновляет счётчик, пока условие в объявлении цикла соблюдается (т.е. проверка условия возвращает true);
сокращенный for (в других языках известен как foreach) – перебирает массив от первого элемента до последнего и на каждой итерации выполняет тело цикла.
Если мы используем конструкции с while, значение нужно указать перед началом цикла:
int a = 1;
System.out.println(a);
a++; //увеличиваем а на единицу
Если же переменная работает как счётчик цикла, а за его пределами не используется, её инициализируют прямо в условии. И тут же пишут, что с ней делать в конце каждой итерации. Всё это – в одну строку – с помощью for:
System.out.println(a);
Получаем тот же результат. Список можно было начать с нуля или с отрицательного значения – диапазон определяем сами.
Сокращенный вариант цикла for не содержит указаний ни на число повторов, ни на действия в конце шага. Цикл типа foreach используют для перебора массивов. От первого элемента нужно переходить к следующему – пока массив не кончится.
int[] ms = < 1, 2, 3, 4>; //создаем массив
int s = 0;
s *= i; //последовательно перемножаем элементы
System.out.println(s);
Вложенные циклы Java
Циклы можно вкладывать один в другой. При этом число повторов наружного и вложенных циклов умножается. Если внешний должен выполняться 5 раз и внутренний – 5, всего цикл будет выполнен 25 раз.
Выведем таблицу умножения с помощью двух массивов:
int a, b, result = 0;
result = a*b;
Как создать цикл
Циклы позволяют в зависимости от определенных условий выполнять некоторое действие множество раз. В JavaScript имеются следующие виды циклов:
Цикл for
Цикл for имеет следующее формальное определение:
for ([инициализация счетчика]; [условие]; [изменение счетчика]) < // действия >
Например, используем цикл for для перебора чисел от 0 до 4:
for(let i = 0; i console.log("Конец работы");
Первая часть объявления цикла - let i = 0 - создает и инициализирует счетчик - переменную i. И перед выполнением цикла ее значение будет равно 0. По сути это то же самое, что и объявление переменной.
Третья часть - i++ - приращение счетчика на единицу.
То есть при запуске переменная i равна 0. Это значение отвечает условию i
console.log(i);
После выполнения блока цикла выполняется треться часть объявления цикла - приращение счетчика. То есть переменная i сановится равной 1. Это значение также отвечает условию, поэтому блок цикла снова выполняется. Таким образом, блок цикла сработает 5 раз, пока значение i не станет равным 5. Это значение НЕ отвечает условию, поэтому произойдет выход из цикла. И управление программой перейдет к инструкциям, которые идут после блока цикла. Консольный вывод программы:
0 1 2 3 4 Конец работы
Каждое отдельное повторение цикла называется итерацией. Таким образом, в данном случае сработают 5 итераций.
При этом необязательно увеличивать счетчик на единицу, можно производить с ним другие действия, например, уменьшать на единицу:
for(let i = 10; i > 5; i--)
В данном случае на консоль выводится числа от 10 до 6.
Или увеличим счетчик на 2:
for(let i = 0; i
Здесь выводятся на консоль все четные числа от 0 до 8
При этом можно опускать различные части объявления цикла:
let i = 0; for(; i
В данном случае переменная i определена вне цикла. В самом объявлении цикла есть только условие, остальные две части отсутствуют. Изменение переменной происходит в самом блоке цикла: оно увеличивается на 10. В итоге на консоль будут выведены числа 0, 10, 20, 30, 40, 50.
Счетчик удобно использовать как индекс элементов массива и таким образом перебирать массив:
const people = ["Tom", "Sam", "Bob"]; for(let i=0; i
Консольный вывод браузера:
Tom Sam Bob
Применение нескольких счетчиков в цикле
При необходимости можно использовать несколько счетчиков:
for(let i = 1, j=1; i < 5, j < 4; i++, j++)< console.log(i + j); >// 1 итерация: i=1, j=1; i + j = 2 // 2 итерация: i=2, j=2; i + j = 4 // 3 итерация: i=3, j=3; i + j = 6
Здесь теперь используются два счетчика и два условия. Рассмотрим пошагово, что здесь происходит:
-
Первая итерация. Начальные значения переменных i и y:
i=1, j=1;
Для каждой переменной установлены свои условия. И вначале начальные значения переменных соответствуют этим условиям:
В блоке цикла выводится сумма этих переменных. И дальше значения обоих переменных увеличиваются на единицу. Они становятся равны
i=2, j=2;
i=2, j=2;
После выполнения блока цикла значения обоих переменных увеличиваются на единицу. Они становятся равны
i=3, j=3;
i=3, j=3;
После выполнения блока цикла значения обоих переменных увеличиваются на единицу. Они становятся равны
i=4, j=4;
Выполнение действий в объявлении цикла
Стоит отметит, что третья часть цикла, где обычно происходит изменение счетчика в реальности представляет произвольное действие, которое выполняется после завершения цикла. Так, мы можем написать следующим образом:
for(let i = 0; i < 5; console.log(i++)); console.log("Конец работы");
Здесь не определено блока цикла, а сами действия цикла определены в третьей части заголовка цикла - console.log(i++)
Аналогично в первой части определения цикла - инициализации мы можем выполнять некоторые действия, а не обязательно только объявление счетчика:
let i=0; for(console.log("Init"); i
Здесь определение счетчика вынесено вне цикла, а в инициализационной части цикла на консоль выводится строка. Вывод браузера:
Init 0 1 2 3 4
Вложенные циклы
Одни циклы могут внутри себя содержать другие:
for(let i=1; i >
Здесь один цикл включается в себя другой. ВО внешнем цикле определяется переменная i. Вначале она равна 1 и это значение соответствует условию цикла ( i
Во внутреннем цикле определяется переменная-счетчик j, которая изначально равна 1, и потом внутренний цикл выполняет 5 итераций, пока переменная j не станет равна 5.
После того, как блок внешнего цикла завершен, переменная i увеличивается на 1 и становится равной 2, что опять же соответствует условию. И снова выполняется блок внешнего цикла. В этом блоке снова выполняются пять итераций внутреннего цикла. И так далее. В итоге внутренний цикл будет выполняться 25 раз.
Используя вложенные циклы и несколько счетчиков можно перебирать многомерные массивы:
const people = [["Tom", 39], ["Sam", 28],["Bob", 42]]; for(let i=0; i < 3; i++)< // перебираем двухмерный массив for(let j=0; j < 2; j++)< // перебираем вложенные массивы console.log(people[i][j]); >console.log("================ browser"> Tom 39 ================= Sam 28 ================= Bob 42 =================
Цикл while
Цикл while выполняется до тех пор, пока некоторое условие истинно. Его формальное определение:
while(условие) < // действия >
Опять же выведем с помощью while числа от 1 до 5:
let i = 1; while(i
Цикл while здесь будет выполняться, пока значение i не станет равным 6.
do..while
В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно, цикл повторяется. Например:
let i = 1; do< console.log(i); i++; >while(iЗдесь код цикла сработает 5 раз, пока i не станет равным 5. При этом цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно.
Операторы continue и break
Иногда бывает необходимо выйти из цикла до его завершения. В этом случае мы можем воспользоваться оператором break :
for(let i=1; i console.log("Конец работы");Данный цикл увеличивает переменную i c 1 до 6 включая, то есть согласно условию цикла блок цикла должен выполняться 6 раз, то есть поизвести 6 итераций. Однако поскольку в блоке цикла происходит поверка if(i===4) break; , то, когда значение переменной i достигнет 4, то данное условие прервет выполнение цикла с помощью оператора break. И цикл заершит работу.
1 2 3 Конец работыЕсли нам надо просто пропустить итерацию, но не выходить из цикла, мы можем применять оператор continue . Например, изменим предыдущий пример, только вместо break используем оператор continue :
for(let i=1; i console.log("Конец работы");В этом случае, когда значение переменная i станет равной 4 , то выражение i===4 возвратит true , поэтому будет выполняться конструкция if(i===4) continue; . С помощью оператора continue она завершит текущую итерацию, далее идущие инструкции цикла не будут выполняться, а произойдет переход к следующей итерации:
1 2 3 5 6 Конец работыfor..in
Цикл for..in предназначен главным образом для перебора объектов. Его формальное определение:
for (свойство in объект) < // действия >Этот цикл перебирает все свойства объекта. Например:
const person = ; for(prop in person)
Здесь перебирается объект person, который имеет два свойства - name и age. Соответственно на консоли мы увидим:
name ageПолучив свойтсва и используя специальный синтаксис объект[свойство] , мы можем получить значение каждого свойства:
const person = ; for(prop in person)
name Tom age 37Цикл for. of
Цикл for. of предназначен для перебора наборов данных. Например, строка представляет фактически набор символов. И мы можем перебрать ее с помощью данного цикла:
const text = "Hello"; for(char of text)
В итоге цикл перебирает все символы строки text и помещает каждый текущий символ в переменную ch , значение которой затем выводится на консоль.
H e l l oДругим примером может быть перебор массива:
const people = ["Tom", "Sam", "Bob"]; for(const person of people)
В данном случае цикл перебирает элементы массива people. Каждый элемент последовательно помещается в константу person . И далее мы можем вывести ее значение на консоль: