Операторы циклов в javascript for of. Циклы в JavaScript

Как и в других языках программирования, в JavaScript реализованы циклы .
Несколько слов об их основном предназначении. Предположим у нас есть блок кода, который точно необходимо повторить некоторое количество раз подряд:

Var mew = "Mew!";
console.log("Cat says:");

// here is repeating code
console.log(mew);
console.log(mew);
console.log(mew);
console.log(mew);

В данном случае мы повторяем запись в консоль строки "Mew!" ровно 4 раза. Мы видим, что если нам придется повторять какой-нибудь более сложный блок кода, то это будет весьма громоздко. Таким образом необходим механизм, который повторит некоторый блок кода требуемое количество раз. Как раз это и делает цикл .

В JS используются циклы, аналогичные другим популярным языкам программирования (C/C++, PHP, JAVA):

• for () - повторяет некоторый блок кода в зависимости от заданных параметров


• while (booleanExpression) - повторяет некоторый блок кода в зависимости от логического значения booleanExpression


• do-while (booleanExpression) - аналог предыдущего типа цикла, но со своей особенностью

После каждой из этих конструкций необходимо указать сгруппированный при помощи фигурных скобок { } блок кода, который будет повторяться. Повторения в самом цикле называются итерациями . Блок кода, который повторяется называют телом цикла .

В этом уроке рассмотрим цикл for() . В качестве значения опций необходимо указать три "параметра" S1; C1; S2 , которые разделены точкой с запятой:

For (S1; C1; S2) {
code-to-repeat;
}

Параметр S1 - это инструкция, которая будет выполнена перед первой итерацией . Фактически это инициализация цикла.

Параметр C1 - это логическое выражение или значение, которое будет проверятся перед каждой итерацией цикла. Если значение этого выражение true, то выполняется последующая итерация. В противном случае - цикл прекращается. Фактически - это условие продолжения работы цикла. Заметим, что для первой итерации эта проверка будет выполнена после выполнения инструкции S1 .

Параметр S2 - это инструкция, которая выполняется после каждой итерации .

Схематически это можно представить на следующем изображении:

Теперь вернемся к нашему примеру и перепишем его, используя цикл for:

Тут в качестве инструкции S1 выступает определения и инициализация переменной i . В качестве условия продолжения работы цикла выступает выражение i <= 4 . В качестве инструкции S2, которая выполняется после каждой итерации, выступает операция инкремента переменной i - увеличение ее значения на 1 . Таким образом, получим повторение записи в консоль значения переменной mew ровно 4 раза. Переменная i в таких циклах называется счетчиком .

Рассмотрим еще один пример применения этого цикла - перебор значений массива.

Var arr = ;

For (i = 0; i console.log(arr[i]);
}

В данном случае мы динамически создали переменную i , которая является счетчиком итераций, а в условии использовали свойство объекта массива, которое содержит количество его элементов.

История образования современного синтаксиса языка программирования сродни познанию процессов образования Вселенной. Что и как было вначале... Но теперь все просто и доступно.

Алгоритм в конечном итоге - всегда последовательная цепочка команд. Параллельность в программировании - совокупность как-то скомбинированных последовательностей. никогда не был практичнее последовательной или параллельной цепочки команд. Метки, переходы и условия - всего было достаточно для любого решения. Функциональные языки лишили значимости эти идеи, но необходимость повторения участков кода осталась.

Браузер: DOM, его язык + сервер

На JavaScript циклы остались, хотя функциональные идеи приобрели особенный смысл. Возможно что-то осталось от "Лиспа" и "Пролога", но, скорее всего, область, где обитает JavaScript, привела к тому что есть, но сомнительно что это последнее решение.

JavaScript работает внутри браузера, который получает страницу, разбирает ее в DOM и запускает первый скрипт. Все остальные страницы, в том числе загруженные на данной - дело рук разработчика, манипулирующего языком, посредством которого может быть вызван код на сервере и получен результат при помощи механизма AJAX.

Браузер исполняет JavaScript-код, который может пользоваться объектами браузера, включая тот, что обеспечивает передачу информации на сервер и получение ответа, в качестве которого может выступать как HTML-разметка, так и стили и собственно код. Ответ может быть представлен массивами и объектами. Смысл использовать на JavaScript циклы теряется, возможностей обойтись без них предостаточно, а рисковать повесить браузер бесконечной последовательностью команд не самое лучшее решение.

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

Положение JavaScript в пространстве кода

Современный программист даже не задумывается, что используемый им while, do while, ...) - в конечном итоге серия тактов (циклов) процессора, простая последовательность двоичных операций, прерываемая проверками счетчиков, то есть условиями.

Как такового цикла нет на уровне машинного языка: есть комбинация обычных команд, условных операций и переходов. Уровнем выше, какое бы средство ни было использовано для разработки браузера и интерпритатора JavaScript, циклы будут однозначно. Причем «куски кода» будут представлены разными временами и разными поколениями программистов. Этажом выше находится «здание» JavaScript. Синтаксис которого предлагает современые JavaScript циклы.

JS - прекрасный язык: практичный, современный и полнофункциональный. Синтаксис этого инструмента включает в себя все конструкции, которые прошли проверку временем и стали незыблемым фундаментом любого алгоритма. Но так ли необходимы циклы на самом деле? Прогресс в программировании часто задавал себе вопросы фундаментального характера, но только в некоторых случаях находил решение.

Объективные основания

Цикл может быть всего двух вариантов: по условию или по счетчику, но по сути (на самом низком уровне) любой цикл - только по условию. В некоторых языках встречается цикл "по каждому". На JavaScript циклы foreach представлены конструкцией prop in object, но можно использовать вариант array.forEach(...).

В любом случае вариантов два: который исполняет в конечном итоге все алгоритмы программиста, даже пишущего на интерпретирующих языках, не имеет никаких иных вариантов повтора цепочки команд: он может что-то выполнять еще раз, пока:

• счетчик считает;
• пока условие выполняется.

JavaScript - типичный интерпретатор. Его особенность: он функционирует внутри браузера, использует его объекты и позволяет исполнять алгоритмы на стороне клиента, как при загрузке страницы в браузер, так и в процессе ее работы.

Простой цикл по-каждому

На JavaScript циклы foreach выглядят как применение к массиву функции:

Применение таких циклов не вызывает трудностей. Формально здесь нет как такового цикла. Есть последовательное обращение функции к элементам массива.

Цикл по счетчику

Более привычно выглядят на JavaScript циклы for:

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

Условные циклы

Вариант с while JavaScript предлагает в зависимости от того, когда нужно проверять условие. Если тело цикла может быть не исполнено ни разу - это одно, если тело должно быть исполнено хотя бы один раз, это другое:

В первом случае, интерпретируя конструкцию while, JavaScript сначала проверяет условие, и если оно истинно, то выполняет цикл. Во втором случае сначала будет исполнен цикл. Если в результате изменения переменных, указанных в условии конструкции do while, оно примет ложное значение, выполнение цикла прекратится.

Массивные комбинации простых алгоритмов

Основная задача (составляющая часть) любого алгоритма - найти, только потом принять решение касательно того, что делать дальше. Самый примитивный вариант поиска - обращение к переменной, результат получается непосредственно. Если переменных много, или у нее много значений (массив), то для выборки значения необходимо найти то, что определит дальнейшее поведение скрипта.

Такая простая доктрина сделала цикл со счетчиком в языке JavaScript своеобразной панацеей от всех задач. Современные компьютеры отличаются быстротой. Времени для выполнения скриптов в браузере предостаточно, спешить некуда. Проще простого перебрать что-то ради чего-то. В результате на JavaScript циклы for приобрели большую популярность.

Плохого в этом вроде ничего нет. Но за таким подходом легко теряется сущность, ради которой пишется тот или иной алгоритм. Данные не бывают беспредметными. Все, ради чего пишется любая программа, имеет смысл. Чрезмерно употребляя на JavaScript циклы for, разработчик может не разглядеть нужную сущность и не создать адекватный алгоритм.

Функциональность, другое отображение реальности

Применяя JavaScript-циклы, примеры однотипного кода можно представить функциями - алгоритм сразу преобразится, основное тело скрипта уменьшится в размере, все станет читаемым и понятным.

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

var cResult = "9,8,7,6,5,4" ;
var aResult = cResult .split ("," );

Здесь нет никакого цикла, но как иначе выполняется эта не путем поиска символа "," и использования его для отделения одного числа от другого.

Абстрагируясь от того, как это реализуется внутри функции split(), можно дополнить JavaScript своим функционалом, использующим циклы, с точки зрения использования - более удобным. Существенно, что такой подход приводит к разработке функционала для каждой задачи соответственно, но общее все же будет при таком подходе.

Эти функции allt(), padc(), padl() и padr() - то, чего нет в JavaScript, но иногда нужно убрать из строки пробелы или выровнять длину строки слева, справа или с обоих сторон. В теле этих функций - JavaScript-циклы. Просто, доступно и никогда не повиснет алгоритм, использующий это.

Варианты функций преобразования чисел из 16-ричной в 10-ную систему исчисления и обратно, проще сказать, из одного формата данных в другой, выполнены здесь посредством циклов do while. Очень компактный и эффективный синтаксис языка.

Правильные циклы - отображение реальности

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

Мышление программиста, использующего JS, отличается от мышления программиста PHP (в частности, и других языков в совокупности, ну разве что "Пролог" и его последователи не входят в общее русло), когда алгоритм не ограничивается переменными, массивами, операторами присваивания, циклическими конструкциями.

Если представить, что циклов нет, а задачу решить надо, то самый простой вариант (повязка на глаза) - предположить, что программа обрабатывает данные, которые есть точкой или системой точек в информационном пространстве. Что такое точка и что такое система точек - дело конкретной предметной области. Для программиста этот тезис обозначает: есть простое данное и есть совокупность простых данных. Естественно, простое данное одного уровня для уровня ниже будет системой, а для уровня выше - точкой.

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

Такой подход стар, как идея языков программирования, но до сих пор не нашел своего адекватного отражения в программировании. Многие программисты мыслят правильно, но результат их творчества оставляет желать лучшего.

Полезно иногда надевать повязку на глаза, чтобы увидеть мир!

Цикл for - наиболее используемый вариант организации цикла в JavaScript.

Его конструкция выглядит так:

For (начало; условие; шаг) { /* тело цикла */ }

Всё на самом деле просто. Давайте рассмотри пример:

Var i; for (i = 1; i

В этом примере:

• Начало цикла : i = 1 (начиная со значения i = 1)
• Условие цика : i
• Шаг цикла : i++ (при каждом шаге цикла i увеличивать на 1)
• Тело цикла : document.write("

  Выполняется шаг цикла номер:" + "

  "); (выводить на экран сообщение)

Пошаговый алгоритм выполнения этого цикла for, более детально:

1. Начало цикла: переменной i присваивается значение 1. Эта часть цикла выполняется один раз.
2. Проверяется условие цикла (i 5) - конец цикла.
3. Выполняется тело цикла.
4. Выполняется шаг цикла. В шашем случае i++. Он всегда выполняется после тела цикла.
5. Возвращение на пункт 2.

Если тело цикла состоит из одной инструкции, то фигурные скобки {...} ставить не обязательно.

Переменная i после завершения цикла не исчезает. Она продолжает существовать и её значение после завершения цикла будет равно 6.

Давайте обощим эти данные в новом примере:

Var i; for (i = 1; i

Тут для создания тела цикла фигурные скобки не использовались.

Фигурные скобки {...} образуют блок в JavaScript - это одна из консрукций языка. То есть, если после оператора цикла for стоят фигурные скобки, это значит что обработчик JavaScript должен выполнить весь блок JavaScript.

Аналогично блоку, в цикле for можно указать функцию. Вот пример:

For (var i = 1; i

Но вот при объявлении функции фигурные скобки {...} обязательны. Их отсутствие приведёт к ошибке.

Обратите внимание, в этом цикле переменная i объявлена в начале цикла: for (var i = 1 ; i

Пропуск частей for

Вообще, начало цикла можно и не прописывать:

Var i = 1; for (; i

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

Также можно убрать шаг:

Var i = 1; for (; i

Этот цикл for превратился в аналог цикла while (i

В условие можно поставить выражение, изменяющее переменную.

For (i = 10; i--;) { document.write("

Выполняется шаг цикла: " + i + ".

"); }

Так как интерпретатор JavaScript когда ожидает получить логическое значение, любое значение приводит к логическому типу, то когда в результате очередного дикремента переменная i станет равной 0 (ложь), цикл остановится.

Безконечный цикл for

Да, да, я знаю что правильно писать бесконечный:)

Итак, цикл будет безконечный, если условие всегда будет истиной. Вот пример:

For (var i = 1; i

В этом примере переменная i будет уменьшаться и никогда не станет больше пяти. Цикл будет выполняться вечно. Попробуйте запустить этот скрипт. У меня Хром "задумался" и ничего не выдал на экран, а продолжал думать и думать.

Будте внимательны и избегайте случайного создания безконечных циклов.

Прерывание цикла for

Для прерывания цикла for, как и для прерывания любого другого цикла, используется команда break . Когда обработчик JavaScript обнаруживает команду break в теле цикла, он останавливает выполнения цикла и начинает выполнять инструцкии сценария, следующие за циклом. если такие имеются.

В следующем примере мы остановим цикл на третьей итерации (третьем шаге).

For (var i = 1; i

Немного усложним пример

Выполним только 100 итераций безконечного цикла.

Var $counter = 1; for (var i = 1; i

Следующая итерация: continue

Команда continue завершает текущую итерацию и начинает выполнять следующую.

Директива continue «младшая сестра» директивы break, она останавливает только итерацию, а не весь цикл.

For (var i = 1; i

Цикл ниже использует continue , чтобы выводить нечетные значения:

For (var i = 0; i

Конечно, нечётные значения можно вывести при помощи такого цикла без директивы continue :

For (var i = 0; i

Директивы break / continue в операторе "?"

Давайте кратко опишем оператор вопросительный знак "? ". Он похож на конструкцию if .

Логическая конструкция:

If (условие) { a(); } else { b(); }

Работает также, как и код с оператором "? ".

Условие? a() : b(); var i = 2; document.write("

Часть 1.

"); if (i == 2) document.write("

Условие сработало.

"); else document.write("

Условие не сработало.

"); document.write("

Часть 2.

"); i == 2 ? document.write("

Условие сработало.

") : document.write("

Условие не сработало.

");

Так вот, важно , нельзя использовать break/continue справа от оператора "? "

В JavaScript синтаксические конструкции, не возвращающие значений, запрещено использовать в операторе "? ".

Нижний пример не рабочий, в нём содержится ошибка:

For (var i = 0; i

Метки для break / continue

Иногда возникает необходимость создавать вложенные циклы. В таком случае во время работы вложенного цикла может возникнуть необходимость остановить родительский цикл или остановить итерацию родительского цикла. Для этого используются метки.

Вы можете применять метки для обозначения циклов, чтобы затем при помощи break или continue выходить из цикла или продолжать работу цикла с новой итерации.

Метки - единственный способ для команд break и continue повлиять на выполнение внешнего цикла.

Инструкция метки (англ. label) используется только вместе с break или continue для альтернативного выхода из цикла.

Метка имеет синтаксис "имя:", имя метки должно быть уникальным. Метка ставится перед циклом, в той же строке или с переносом строки.

Аналогично можно в этом месте использовать директиву break . Но в случае её использования, как вы понимаете, выполнение циклов прекратится.

Var i, j; metka1: for (i = 0; i

В языке JavaScript нет оператора goto , как в PHP, возможно использовать только метки с break или continue .

Метки редко используются при программировании на JavaScript, так как считается что они делают код сложнее в чтении ипонимании. При кодировании рекомендуется использовать функции.

Циклы предназначены для многократного выполнения одних и тех же инструкций.

На языке JavaScript существует 4 вида циклов:

• Цикл for . Этот цикл используется, когда известно точное количество повторений одних и тех же инструкций.
• Цикл while . Он предназначен для выполнения одних и тех же инструкций до тех пор, пока заданное условие истинно.
• Цикл do...while . Данный цикл аналогичен циклу while , но условие проверяется не перед выполнением повторяющихся инструкций, а после них. Таким образом, в отличие от цикла while , даже если условие изначально ложное, инструкции выполнятся хотя бы один раз.
• Цикл for...in . Он применяется, когда необходимо перебрать все свойства в объекте или каждый элемент в массиве.

Цикл for

Синтаксис цикла for:

For (инициализация; условие; финальное выражение) { /* тело цикла */ }

• инициализация - это выражение, которое выполняется один раз перед выполнением цикла; обычно используется для инициализации счётчика;
• условие - это выражение, истинность которого проверяется перед каждой итерацией; если выражение вычисляется как истина, то выполняется итерация, в противном случае цикл for завершает работу;
• финальное выражение - это выражение, которое выполняется в конце каждой итерации; обычно используется для изменения счетчика;
• тело цикла - инструкции, выполнение которых нужно повторять.

Рассмотрим пример цикла, который выведет в консоль числа от 1 до 9:

Var i; // Цикл for от 1 до 9, с шагом 1 for (i = 1; i <= 9; i++) { console.log(i); }

В этом примере:

• инициализация: i = 1 (присвоение переменной i значения 1);
• условие прекращение цикла: i <= 9 (значение переменной i не меньше 9);
• выражение, которое нужно выполнять в конце каждой итерации: i++ (увеличение значение переменной i на 1);
• инструкция, которую нужно выполнять: console.log(i) (выведение значения счётчика в консоль).

Необязательные части цикла for

В for блок инициализации является не обязательным.

Var i = 1; // Цикл for for (; i <= 9; i++) { console.log(i); }

Блок условия в цикле for тоже является не обязательным. Без условия цикл будет выполняться бесконечное количество раз. В этом случае чтобы его прервать (выйти из цикла) необходимо использовать инструкцию break .

Var i; // Цикл for for (i = 1; ; i++) { if (i > 9) { // условие прерывание цикла break; } console.log(i); }

Финальное выражение в for также является не обязательным. Счётчик цикла в этом случае можно, например, изменять в теле.

Var i; // Цикл for for (i = 1; i <= 9 ;) { console.log(i); i++; }

Можно вообще опустить 3 выражения:

Var i = 1; // Цикл for for (; ;) { if (i > 9) { break; } console.log(i); i++; }

В качестве тела цикла for можно использовать пустое выражение (;).

Например:

Var arrA = , arrB = ; for (i = 0; i < arrA.length; arrB[i] = arrA / 2) ; console.log(arrB); //

Примеры использования for

Использование цикла for для перебора элементов массива:

Var arr = , // массив i = 0, // счетчик lenArr = arr.length; // длина массива for (i; i < lenArr; i++) { console.log(arr[i]); }

Инструкции break и continue

Кроме этого, внутри тела циклов могут использоваться специальные инструкции break и continue .

Оператор break предназначен для прекращения выполнения цикла. Т.е. он осуществляет выход из текущего цикла и передачи управления инструкции, идущей после него.

Оператор continue прерывает выполнение текущей итерации цикла и осуществляет переход к следующей.

Пример, в котором выведим в консоль нечётные числа от 1 до 11:

Var i; for (i = 1; i <= 11; i++) { // если число в переменной i чётное, то переходим к следующей итерации if (i %2 === 0) { continue; } // выведим значение переменной i в консоль console.log(i); } // 1, 3, 5, 7, 9, 11

Цикл c предусловием while

Цикл while выполняет одни и те же инструкции (тело цикла) до тех пор, пока истинно некоторое условие. Истинность условия проверяется перед каждым выполнением тела цикла. Если перед первой итерацией условие ложно, то цикл не выполняется ни разу.

// объявление переменной а и присвоение ей значения 0 var a=0; //цикл while с условием a

Цикл с постусловием do...while

Цикл do...while , так же как и цикл while , выполняет одни и те же инструкции (тело цикла) до тех пор, пока некоторое условие истинно. Но в отличие от цикла while , в цикле do...while условие проверяется после каждого выполнения тела цикла. Если даже условие изначально ложно, то тело цикла всё равно выполнится один раз (т.к. условие проверяется после выполнения тела цикла).

// объявление переменной а и присвоение ей значения 0 var a=0; //цикл do...while с условием a

Как было отмечено выше, цикл for...in находит применение для перебора элементов массива и свойств объекта. На этом уроке мы рассмотрим только общий синтаксис цикла for...in , а более подробно познакомимся с ним в следующих уроках.

Принцип работы цикла for...in заключается в том, что переменная x принимает все имена свойств объекта y или индексы массива y . Таким образом, в каждой итерации вам доступно свойство объекта или элемент массива.

Циклы - это особые выражения, позволяющие выполнить один и тот же блок кода несколько раз. Выполнение кода прерывается по наступлению некоего условия.

JavaScript предлагает программистам несколько разновидностей циклов . Рассмотрим их подробнее.

Цикл со счетчиком

Цикл со счетчиком удобен, если какой-то код нужно выполнить строго определенное число раз. Вероятно, это наиболее распространенный вид цикла.

Цикл со счетчиком записывается так:

for (<выражение инициализации>; <условие>; <приращение>)
<тело цикла>

Здесь используется ключевое слово for. Поэтому такие циклы часто называют "циклами for".

Выражение инициализации выполняется самым первым и всего один раз. Оно присваивает особой переменной, называемой счетчиком цикла, некое начальное значение (обычно 1). Счетчик цикла подсчитывает, сколько раз было выполнено тело цикла - собственно код, который нужно выполнить определенное количество раз.

Следующий шаг - проверка условия. Оно определяет момент, когда выполнение цикла прервется и начнет выполняться следующий за ним код. Как правило, условие сравнивает значение счетчика цикла с его граничным значением. Если условие возвращает true, выполняется тело цикла, в противном случае цикл завершается и начинается выполнение кода, следующего за циклом.

После прохода тела цикла выполняется выражение приращения, изменяющее значение счетчика. Это выражение обычно инкрементирует счетчик (увеличивает его значение на единицу). Далее снова проверяется условие, выполняется тело цикла, приращение и т. д., пока условие не станет равно false.

Пример цикла со счетчиком:

for (i = 1; i < 11; i++) {
a += 3;
b = i * 2 + 1;
}

Этот цикл будет выполнен 10 раз. Мы присваиваем счетчику i начальное значение 1 и после каждого выполнения тела цикла увеличиваем его на единицу. Цикл перестанет выполняться, когда значение счетчика увеличится до 11, и условие цикла станет ложным.

Счетчик цикла можно записать в одном из выражений тела цикла, как это сделали мы. В нашем случае счетчик i будет содержать последовательно возрастающие значения от 1 до 10, которые используются в вычислениях.

Приведем еще два примера цикла со счетчиком:

for (i = 10; i > 0; i--) {
a += 3;
b = i * 2 + 1;
}

Здесь значение счетчика декрементируется. Начальное его значение равно 10. Цикл выполнится 10 раз и завершится, когда счетчик i будет содержать 0; при этом значения последнего будут последовательно уменьшаться от 10 до 1.

for (i = 2; i < 21; i += 2) b = i * 2 + 1;

А в этом примере начальное значение счетчика равно 2, а конечное - 21, но цикл выполнится, опять же, 10 раз. А все потому, что значение счетчика увеличивается на 2 и последовательно принимает значения 2, 4, 6... 20.

Цикл с постусловием

Цикл с постусловием во многом похож на цикл со счетчиком: он выполняется до тех пор, пока остается истинным условие цикла. Причем условие проверяется не до, а после выполнения тела цикла, отчего цикл с постусловием и получил свое название. Такой цикл выполнится хотя бы один раз, даже если его условие с самого начала ложно.

Формат цикла с постусловием:

do
<тело цикла>
while (<условие>);

Для задания цикла с постусловием предусмотрены ключевые слова do и while, по-этому такие циклы часто называют "циклами do-while".

Вот пример цикла с постусловием:

do {
a = a * i + 2;
++i;
} while (a < 100);

А вот еще один пример:

var a = 0, i = 1;
do {
a = a * i + 2;
++i;
} while (i < 20);

Хотя здесь удобнее был бы уже знакомый нам и специально предназначенный для таких случаев цикл со счетчиком.

Цикл с предусловием

Цикл с предусловием отличается от цикла с постусловием тем, что условие проверяется перед выполнением тела цикла. Так что, если оно (условие) изначально ложно, цикл не выполнится ни разу:

while (<условие>)
<тело цикла>

Для создания цикла с постусловием предусмотрено ключевое слово while. Поэтому такие циклы называют еще "циклами while" (не путать с "циклами do-while"!).

Пример цикла с предусловием:

while (a < 100) {
a = a * i + 2;
++i;
}

Прерывание и перезапуск цикла

Иногда бывает нужно прервать выполнение цикла. Для этого JavaScript предоставляет Web-программистам операторы break и continue.

Оператор прерывания break позволяет прервать выполнение цикла и перейти к следующему за ним выражению:

while (a < 100) {
a = a * i + 2;
if (a > 50) break;
++i;
}

В этом примере мы прерываем выполнение цикла, если значение переменной a превысит 50.

Оператор перезапуска continue позволяет перезапустить цикл , т. е. оставить невыполненными все последующие выражения, входящие в тело цикла, и запустить выполнение цикла с самого его начала: проверка условия, выполнение приращения и тела и т. д.

Пример:

while (a < 100) {
i = ++i;
if (i > 9 && i < 11) continue;
a = a * i + 2;
}

Здесь мы пропускаем выражение, вычисляющее a , для всех значений i от 10 до 20.