Цикл со счетчиком в языке javascript. Циклы for в JavaScript

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

Если будет такая задача, например, вывести на экран строку "всем привет" 1000 раз. То, без использования цикла, во первых это займёт много времени и во вторых, это будет смотреться не очень красиво. Поэтому циклы нужно знать на отлично , потому что они используются очень и очень часто.

В программировании существуют четыре цикла, это while, do-while, for и foreach . Каждый из них имеет свой синтаксис и каждый используется в определённых случаях.

Чаще всего используются циклы for и foreach, затем while, а цикл do-while встречается очень редко.

И начнём мы с цикла while.

Синтаксис цикла while следующий:

Сначала объявляем переменную i, которая является счётчиком и внутри цикла мы этот счётчик инкрементируем. Внутри круглых скобок пишем условие входа/выхода из цикла.

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

Для примера выведем строку "Всем привет!" 10 раз.

Var i = 0; while(i "); i++; }

Переменная i, может начаться как с 0 так и с 1 или с другого любого числа.

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

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

Замечание! Не забудьте инкрементировать счётчик (i++), иначе опять же получится бесконечный цикл.

С циклом while разобрались, теперь перейдём к циклу do-while.

Синтаксис цикла do-while следующий:

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

Замечание! Как и у цикла while, не забудьте инкрементировать счётчик i.

Перейдём к практике. Для примера посчитаем произведение чисел от 1 до 10.

Var i = 1; var production = 1; do{ production *= i; i++; }while(i

Результатом будет число 3628800. На первом шаге мы сразу вошли в цикл, несмотря на его условие, где выполнилось операция production *= i (это тоже самое что и production = production * 1). Потом инкрементируем счётчик. После инкрементации он имеет значение 2. И в конце проверяем условие, если значение счётчика меньше либо равно 10, то мы идём к следующей итерации цикла, иначе мы выходим из цикла и идём дальше.

Цикл for

Как я уже написал выше цикл for, встречается достаточно часто, поэтому его нужно знать очень хорошо.

Синтаксис цикла for следующий:

Для лучшего понимания решим простую задачу. Допустим нам нужно посчитать сумму чисел от 1 до 1000 с помощью цикла for.

Var summa = 0; for(var i = 1; i

Сохраняем документ, открываем его в браузере и видим, что результат равен 500500.

Замечание! Если в цикле находится только одни оператор, то фигурные скобки использовать необязательно.

Для демонстрации выведем на экран 5 раз, какую то строку, например " Здравствуйте! ".

For(var i = 1; i

Замечание! После выполнения цикла в переменной i, остаётся последнее значение.

Теперь решим задачу чуть по сложнее, например нам нужно вывести строку "Привет" 100 раз. И для того чтобы это все не вывелось в один ряд, то после каждой 10-ой итерации, перейдём на новую строку. И в конце выведем значение переменной i.

For(var i = 1; i <= 100; i++){ document.write("привет!"); if(i % 10 == 0)  document.write("
"); } document.write("

Переменная i = " + i + "

Цикл foreach обычно используется для перебора объектов и массивов. Поэтому о нем я расскажу в статье описывающая работу с массивами.

Оператор break предназначен для того чтобы принудительно выйти из цикла.

Оператор continue позволяет прервать текущую итерацию цикла, и перейти к следующей.

Для лучшего понимания, тоже решим простую задачу. Допустим, мы хотим посчитать сумму нечётных чисел с 1 до 20. И когда дойдём до 15-ой итерации, то выйдем из цикла.

Var summa = 0; for(var i = 1; i <= 20; i++){ //Пропускаем текущею итерацию цикла if(i % 2 == 0) continue; summa += i; //Выходим совсем из цикла. if(i == 15) break; document.write(i + ". Итерация
"); } document.write("

summa = " + summa + "

Сохраняем документ, открываем его в браузере и смотрим на результат.

Для тренировки попробуйте изменить написанный скрипт, таким образом, чтобы он посчитал сумму чётных чисел.

На этом заканчивается эта статья. Теперь Вы знаете синтаксис циклов while, do-while, for и как с ними работать . Также познакомились с операторами break и continue .

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

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

В JavaScript существуют следующие операторы цикла:

1) for используется когда вы заранее знаете, сколько раз вам нужно что-то сделать;
2) for...in используется для обхода свойств объектов;
3) while используется когда вы не знаете, сколько раз нужно что-то сделать;
4) do...while работает аналогично с оператором while . Отличается тем, что do...while всегда выполняет выражение в фигурных скобках, по крайней мере один раз, даже если проверка условия возвращает false .

Типы циклов в JavaScript, управление циклом

1. Цикл for

Цикл for используется для выполнения итераций по элементам массивов или объектов, напоминающих массивы, таких как arguments и HTMLCollection . Условие проверяется перед каждой итерацией цикла. В случае успешной проверки выполняется код внутри цикла, в противном случае код внутри цикла не выполняется и программа продолжает работу с первой строки, следующей непосредственно после цикла.

Следующий цикл выведет на консоль строчку Hello, JavaScript! пять раз.

For (var i = 0; i < 5; i++) { console.log(i + ": Hello, JavaScript!"); }
Рис. 1. Результат выполнения цикла for на консоли

1.1. Как работает цикл for

Цикл for состоит из трёх разных операций:

Шаг 1. инициализация var i = 0; — объявление переменной-счётчика, которая будет проверяться во время выполнения цикла. Эта переменная инициализируется со значением 0 . Чаще всего в качестве счётчиков цикла выступают переменные с именами i , j и k .

Шаг 2. проверка условия i < 5; — условное выражение, если оно возвращает true , тело цикла (инструкция в фигурных скобках) будет выполнено. В данном примере проверка условия идёт до тех пор, пока значение счётчика меньше 5 .

Шаг 3. завершающая операция i++ — операция приращения счётчика, увеличивает значение переменной var i на единицу. Вместо операции инкремента также может использоваться операция декремента.

По завершении цикла в переменной var i сохраняется значение 1 . Следующий виток цикла выполняется для for (var i = 1; i < 5; i++) { } . Условное выражение вычисляется снова, чтобы проверить, является ли значение счётчика i всё ещё меньше 5 . Если это так, операторы в теле цикла выполняются ещё раз. Завершающая операция снова увеличивает значение переменной на единицу. Шаги 2 и 3 повторяются до тех пор, пока условие i < 5; возвращает true .

1.2. Вывод значений массива

Чтобы вывести значения массива с помощью цикла for , нужно задействовать свойство массива length . Это поможет определить количество элементов в массиве и выполнить цикл такое же количество раз.

Приведённый ниже скрипт выведет на экран пять сообщений с названиями цветов:

Var flowers = ["Rose", "Lily", "Tulip", "Jasmine", "Orchid"]; for (var i = 0; i < flowers.length; i++){ alert(flowers[i] + " - это цветок."); }

Если значение свойства length не изменяется в ходе выполнения цикла, можно сохранить его в локальной переменной, а затем использовать эту переменную в условном выражении. Таким образом можно повысить скорость выполнения цикла, так как значение свойства length будет извлекаться всего один раз за всё время работы цикла.

Var flowers = ["Rose", "Lily", "Tulip", "Jasmine", "Orchid"], len = flowers.length; for (var i = 0; i

2. Цикл for...in

Циклы for...in используются для обхода свойств объектов, не являющихся массивами. Такой обход также называется перечислением . При обходе рекомендуется использовать метод hasOwnProperty() , чтобы отфильтровать свойства, которые были унаследованы от прототипа.

Для примера создадим объект с помощью литерала объекта.

Var user = { name: "Alice", age: 25, country: "Russia" }; for (var prop in user) { console.log(prop + ": " + user); }
Рис. 2. Результат выполнения цикла for...in на консоли

Предположим, что в сценарии до или после создания объекта user прототип объекта Object был расширен дополнительным методом clone() .

If (typeof Object.prototype.clone === "undefined") { Object.prototype.clone = function () {}; }

Так как цепочка наследования прототипа постоянно проверяется интерпретатором, то все объекты автоматически получают доступ к новому методу.

Чтобы избежать обнаружения этого метода в процессе перечисления свойств объекта user , используется метод hasOwnProperty() , который отфильтрует свойства прототипа.

Var user = { name: "Alice", age: 25, country: "Russia" }; if (typeof Object.prototype.clone === "undefined") { Object.prototype.clone = function () {}; } for (var prop in user) { if (user.hasOwnProperty(prop)) { console.log(prop + ": " + user); } }
Рис. 4. Результат перечисления свойств объекта с помощью метода hasOwnProperty()

3. Цикл while

Цикл while - цикл с предварительной проверкой условного выражения. Инструкция внутри цикла (блок кода в фигурных скобках) будет выполняться в случае, если условное выражение вычисляется в true . Если первая проверка даст результат false , блок инструкций не выполнится ни разу.

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

Данный цикл выведет на экран таблицу умножения для числа 3:

Var i = 1; var msg = ""; while (i < 10) { msg+= i + " x 3 = " + (i * 3) + "
"; i++; } document.write(msg);
Рис. 5. Результат выполнения цикла while

4. Цикл do...while

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

Var result = ""; var i = 0; do { i += 1; result += i + " "; } while (i < 5); document.write(result);
Рис. 6. Результат выполнения цикла do...while

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

Var i = 10; do { document.write(i + " "); i++; } while (i < 10);

5. Бесконечные циклы

При создании любого цикла можно создать бесконечный цикл, который никогда не завершится. Такой цикл может потенциально продолжать работать до тех пор, пока работает компьютер пользователя. Большинство современных браузеров могут обнаружить это и предложат пользователю остановить выполнение скрипта. Чтобы избежать создания бесконечного цикла, вы должны быть уверены, что заданное условие в какой-то момент вернёт false . Например, следующий цикл задаёт условие, которое никогда не возвращает ложь, так как переменная i никогда не будет меньше 10:

For (var i = 25; i > 10; i++) { document.write("Это предложение будет выводиться бесконечно...
"); }

6. Вложенные циклы

Цикл внутри другого цикла называется вложенным . При каждой итерации цикла вложенный цикл выполняется полностью. Вложенные циклы можно создавать с помощью цикла for и цикла while .

For (var count = 1; count < 3; count++) { document.write(count + ". Строка цикла
"); for (var nestcount = 1; nestcount< 3; nestcount++) { document.write("Строка вложенного цикла
"); } }
Рис. 7. Результат выполнения вложенного цикла for

7. Управление циклом

Циклом можно управлять с помощью операторов break; и continue; .

7.1. Оператор break;

Оператор break; завершает выполнение текущего цикла. Он используется в исключительных случаях, когда цикл не может выполняться по какой-то причине, например, если приложение обнаруживает ошибку. Чаще всего оператор break; является частью конструкции if .

Когда оператор break; используется без метки, он позволяет выйти из цикла или из инструкции switch . В следующем примере создаётся счётчик, значения которого должны изменяться от 1 до 99 , однако оператор break прерывает цикл после 14 итераций.

For (var i = 1; i < 100; i++) { if (i == 15) { break; } document.write(i); document.write("
"); }
Рис. 8. Результат работы оператора break в цикле for

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

Outerloop: for(var i = 0; i < 10; i++) { innerloop: for(var j = 0; j < 10; j++) { if (j > 3) break; // Выход из самого внутреннего цикла if (i == 2) break innerloop; // То же самое if (i == 4) break outerloop; // Выход из внешнего цикла document.write("i = " + i + " j = " + j + "
"); } } document.write("FINAL i = " + i + " j = " + j + "
");

7.2. Оператор continue;

Оператор continue; останавливает текущую итерацию цикла и запускает новую итерацию. При этом, цикл while возвращается непосредственно к своему условию, а цикл for сначала вычисляет выражение инкремента, а затем возвращается к условию.

В этом примере на экран будут выведены все чётные числа:

Var i; for(i = 1; i <= 10; i++) { if (i % 2 !== 0) { continue; } document.write("
чётное число = " + i); }
Рис. 9. Результат работы оператора continue в цикле for

Оператор continue; также может применяться во вложенных циклах с меткой.

Outerloop: for (var i = 0; i "); for (var j = 0; j "); } } document.write("Все циклы выполнены"+"
");
Рис. 10. Результат работы оператора continue с меткой

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

Цикл while

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

Выражение в круглых скобках называется условием выполнения цикла или кратко условием . Сначала вычисляется значение выражения. Полученное значение, если необходимо, неявно преобразуется к булеву типу. Если результатом вычисления выражения является значение true , то инструкция, расположенная в теле цикла, выполняется, затем управление передаётся в начало цикла и условие вычисляется снова. Если результатом вычисления выражения является значение false , интерпретатор завершает работу цикла и переходит к выполнению инструкции следующей за циклом. Таким образом, интерпретатор снова и снова выполняет код расположенный в теле цикла, пока условие остаётся истинным:

Var i = 0; while (i < 3) { // Выполнять код, пока значение переменной i меньше 3 alert("i: " + i); i++; // Увеличиваем значение переменной i }

Цикл do-while

Синтаксис цикла do-while:

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

Var count = 0; do { document.write(count + " "); count++; } while(count < 5); Попробовать »

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

Цикл for

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

В цикле for располагаются три выражения, разделяемые точкой с запятой. Эти три выражения имеют следующий порядок выполнения:

1. Первое выражение всегда вычисляется только один раз - перед первой итерацией. Поэтому обычно в качестве первого выражения выступает определение переменной, которая используется в условии выполнения цикла в качестве счётчика.
2. Второе выражение определяет условие выполнения цикла. Оно вычисляется перед каждой итерацией и определяет, будет ли выполняться тело цикла. Если результатом вычисления выражения является истинное значение, программный код в теле цикла выполняется. Если возвращается ложное значение, выполнение цикла завершается и управление переходит к следующей после цикла инструкции. Если при первой проверке условия, оно оказывается ложным, код в теле цикла не выполнится ни разу.
3. После каждой итерации вычисляется третье выражение. Обычно его используют для изменения значения переменной, которая используется в проверке условия выполнения цикла.

Пример цикла for:

For (var count = 0; count < 5; count++) document.write(count + " "); Попробовать »

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

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

Var i = 0; for (; i < 4; i++) ... var i = 0; for (; i < 4;) ... for (var i = 1; /* нет условия */ ; i++) ... // Это эквивалентно следующему коду for (var i = 1; true; i++) ...

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

// не выполнится, так как в проверке условия последнее выражение false for (i = 1; i < 4, false; i++) ... for (var i = 1, j = 5; i <= 5; i++, j--) document.write(i + " " + j +"
"); Попробовать »

Цикл for-in

Цикл for-in используется для перебора в случайном порядке перечисляемых свойств объекта и имеет следующий синтаксис:

For (переменная in объект) инструкция;

Слева от ключевого слова in указывается имя переменной, которой перед началом каждой итерации цикла присваивается в виде строки имя одного из свойств объекта. Справа от ключевого слова in указывается объект, свойства которого будут перебираться циклом. Цикл будет выполняться до тех пор, пока не будут перебраны все доступные свойства. Если переменная, представляющая объект, будет иметь значение null или undefined цикл не выполнится ни разу:

Var obj = {x: 5, y: 10}; for (var prop in obj) { alert(prop); }

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

Последнее обновление: 08.04.2018

Циклы позволяют в зависимости от определенных условий выполнять некоторое действие множество раз. В JavaScript имеются следующие виды циклов:

for..in

for..of

while

do..while

Цикл for

Цикл for имеет следующее формальное определение:

For ([инициализация счетчика]; [условие]; [изменение счетчика]){ // действия }

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

Var people = ["Tom", "Alice", "Bob", "Sam"]; for(var i = 0; i

Первая часть объявления цикла - var i = 0 - создает и инициализирует счетчик - переменную i. И перед выполнением цикла ее значение будет равно 0. По сути это то же самое, что и объявление переменной.

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

Третья часть - приращение счетчика на единицу.

И так как в массиве 4 элемента, то блок цикла сработает 4 раза, пока значение i не станет равным people.length (то есть 4). И каждый раз это значение будет увеличиваться на 1. Каждое отдельное повторение цикла называется итерацией. Таким образом, в данном случае сработают 4 итерации.

А с помощью выражения people[i] мы сможем получить элемент массива для его последующего вывода в браузере.

Необязательно увеличивать счетчик на единицу, можно производить с ним другие действия, например, уменьшать на единицу:

Var people = ["Tom", "Alice", "Bob", "Sam"]; for(var i = people.length - 1; i >= 0; i--){ console.log(people[i]); }

В данном случае массив выводится с конца, а перебор массива начинается с i = 3 до i = 0.

for..in

Цикл for..in предназначен для перебора массивов и объектов. Его формальное определение:

For (индекс in массив) { // действия }

Например, переберем элементы массива:

Var people = ["Tom", "Alice", "Bob", "Sam"]; for(var index in people){ console.log(people); }

Цикл for...of

Цикл for...of похож на цикл for...in и предназначен для перебора коллекций, например, массивов:

Let users = ["Tom", "Bob", "Sam"]; for(let val of users) console.log(val);

Текущий перебираемый элемент коллекции помещается в переменную val, значение которой затем выводится на консоль.

Цикл while

Цикл while выполняется до тех пор, пока некоторое условие истинно. Его формальное определение:

While(условие){ // действия }

Опять же выведем с помощью while элементы массива:

Var people = ["Tom", "Alice", "Bob", "Sam"]; var index = 0; while(index < people.length){ console.log(people); index++; }

Цикл while здесь будет выполняться, пока значение index не станет равным длине массива.

do..while

В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно, цикл повторяется. Например:

Var x = 1; do{ console.log(x * x); x++; }while(x < 10)

Здесь код цикла сработает 9 раз, пока x не станет равным 10. При этом цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно.

Операторы continue и break

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

< array.length; i++) { if (array[i] > 10) break; document.write(array[i] + "
"); }

Данный цикл перебирает все элементы массива, однако последние четыре элемента не будут выведены в браузере, поскольку поверка if (array[i] > 10) прервет выполнение цикла с помощью оператора break, когда перебор массива дойдет до элемента 12.

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

Var array = [ 1, 2, 3, 4, 5, 12, 17, 6, 7 ]; for (var i = 0; i < array.length; i++) { if (array[i] > 10) continue; document.write(array[i] + "
"); }

В этом случае, если программа встретит в массиве число, больше 10, то это число не будет выводиться в браузере.

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

На языке 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 . Таким образом, в каждой итерации вам доступно свойство объекта или элемент массива.