Выйти из цикла js. Циклы

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

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.

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

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

Браузер: 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 (в частности, и других языков в совокупности, ну разве что "Пролог" и его последователи не входят в общее русло), когда алгоритм не ограничивается переменными, массивами, операторами присваивания, циклическими конструкциями.

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

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

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

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

Последнее обновление: 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, то это число не будет выводиться в браузере.

Что отступы можно считать показателем сложности кода (хотя и довольно грубым). Сами по себе отступы нейтральны, так как они – лишь средство форматирования текста, но всё дело в том, что они используются для выделения особых блоков программ, например – управляющих конструкций. Читая код и натыкаясь на отступ, программист вынужден принимать во внимание то, на что указывает отступ, держать в памяти контекст, в котором существует выделенный блок. Это, естественно, повторяется, если в выделенном отступами участке кода появляется ещё один особый фрагмент.

Если не обращать внимание на содержание текстов, то вот как обычно выглядит сложный код, участки которого похожи на лежащие на боку буквы «V», и простой код, блок которого, если не учитывать разную длину строк, похож на прямоугольник.

Чем больше отступов – тем сложнее обычно и код

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

Возьмём, например, массивы. Традиционно для их обработки используют различные виды циклов. Понятия «массив» и «цикл» неразрывно связаны в сознании многих программистов. Однако цикл – конструкция весьма неоднозначная. Вот что пишет о циклах Луис Атенцио в книге «Функциональное программирование в JavaScript »: «Цикл – это жёсткая управляющая конструкция, которую нелегко использовать повторно и сложно состыковать с другими операциями. Кроме того, использование циклов означает появление кода, который меняется с каждой итерацией.»

Можно ли избавиться от циклов?

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

Циклы

Мы уже говорили о том, что управляющие конструкции, вроде циклов, усложняют код. Но почему это так? Взглянем на то, как работают циклы в JavaScript.

В JS существует несколько способов организации циклов. В частности, один из базовых видов циклов – это while . Прежде чем вникать в подробности, немного подготовимся. А именно – создадим функцию и массив, с которым будем работать.

// oodlify:: String -> String function oodlify(s) { return s.replace(//g, "oodle"); } const input = [ "John", "Paul", "George", "Ringo", ];
Итак, имеется массив, каждый элемент которого мы собираемся обработать с помощью функции oodlify . Если использовать для решения этой задачи цикл while , получится следующее:

Let i = 0; const len = input.length; let output = ; while (i < len) { let item = input[i]; let newItem = oodlify(item); output.push(newItem); i = i + 1; }
Обратите внимание на то, что мы, для того, чтобы отслеживать текущий обрабатываемый элемент массива, используем счётчик i . Необходимо инициализировать его нулём и увеличивать на единицу в каждой итерации цикла. Кроме того, нужно сравнивать его с длиной массива, с len , для того, чтобы знать, когда надо прекратить работу.

Этот шаблон настолько распространён, что в JavaScript имеется более простой способ организовать подобную конструкцию – цикл for . Такой цикл позволит решить ту же задачу следующим образом:

Const len = input.length; let output = ; for (let i = 0; i < len; i = i + 1) { let item = input[i]; let newItem = oodlify(item); output.push(newItem); }
Цикл for – полезная конструкция, так как благодаря ей все стандартные вспомогательные операции со счётчиком выносятся в верхнюю часть блока. Используя while , легко забыть о необходимости инкрементировать счётчик i , что приведёт к запуску бесконечного цикла. Определённо, цикл for гораздо удобнее цикла while . Но давайте притормозим и взглянем на то, чего пытается достичь наш код. Мы хотим обработать, с помощью функции oodlify() , каждый элемент массива и поместить то, что получилось, в новый массив. Сам по себе счётчик, используемый для доступа к элементам массива, нас не интересует.

Подобный шаблон работы с массивами, предусматривающий выполнение неких действий с каждым элементом, весьма распространён. В результате, в ES2015 появилась новая конструкция цикла, которая позволяет забыть о счётчике. Это – цикл for…of . В каждой итерации такого цикла предоставляется следующий элемент массива. Выглядит это так:

Let output = ; for (let item of input) { let newItem = oodlify(item); output.push(newItem); }
Код выглядит гораздо чище. Обратите внимание на то, что тут нет ни счётчика, ни операции сравнения. При таком подходе даже не нужно обращаться к конкретному элементу массива по индексу. Цикл for…of берёт на себя все вспомогательные операции.

Если завершить на этом исследование способов работы с массивами и применять циклы for…of везде вместо циклов for , это уже будет неплохим шагом вперёд за счёт упрощения кода. Но… мы можем пойти дальше.

Трансформация массивов

Цикл for…of выглядит гораздо чище, чем цикл for , но и с ним в коде имеется немало вспомогательных элементов. Так, надо инициализировать массив output и в каждой итерации цикла вызывать метод push() . Код можно сделать ещё более компактным и выразительным, но прежде чем этим заняться, давайте немного расширим демонстрационную задачу. Как быть, если с помощью функции oodlify() надо обработать два массива?

Const fellowship = [ "frodo", "sam", "gandalf", "aragorn", "boromir", "legolas", "gimli", ]; const band = [ "John", "Paul", "George", "Ringo", ];
Вполне очевидное решение – использовать два цикла и обработать массивы в них:

Let bandoodle = ; for (let item of band) { let newItem = oodlify(item); bandoodle.push(newItem); } let floodleship = ; for (let item of fellowship) { let newItem = oodlify(item); floodleship.push(newItem); }
Вполне рабочий вариант. А код, который работает – это гораздо лучше, чем код, который не решает поставленную перед ним задачу. Но два очень похожих фрагмента кода не особенно хорошо согласуются с принципом разработки ПО DRY . Код можно подвергнуть рефакторингу для того, чтобы снизить число повторений.

Следуя этой идее, создаём такую функцию:

Function oodlifyArray(input) { let output = ; for (let item of input) { let newItem = oodlify(item); output.push(newItem); } return output; } let bandoodle = oodlifyArray(band); let floodleship = oodlifyArray(fellowship);
Выглядит это гораздо лучше, но что, если имеется ещё одна функция, с помощью которой мы тоже хотим обрабатывать элементы массивов?

Function izzlify(s) { return s.replace(/+/g, "izzle"); }
Теперь функция oodlifyArray() не поможет. Однако, если создать ещё одну подобную функцию, на этот раз – izzlufyArray() , мы опять повторимся. Всё же, создадим такую функцию и сравним её с oodlifyArray() :

Function oodlifyArray(input) { let output = ; for (let item of input) { let newItem = oodlify(item); output.push(newItem); } return output; } function izzlifyArray(input) { let output = ; for (let item of input) { let newItem = izzlify(item); output.push(newItem); } return output; }
Эти две функции невероятно похожи. Может быть, обобщим шаблон, которому они следуют? Наша цель заключается следующем: «Имеются массив и функция. Нужно получить новый массив, в который будут записаны результаты обработки каждого из элементов исходного массива с помощью функции». Подобный способ обработки массивов называют «отображением» или «трансформацией» (mapping в англоязычной терминологии). Функции, которые выполняют подобные операции, обычно называют «map». Вот как выглядит наш вариант такой функции:

Function map(f, a) { let output = ; for (let item of a) { output.push(f(item)); } return output; }
Хотя цикл теперь и вынесен в отдельную функцию, совсем избавиться от него не получилось. Если пойти до конца и попытаться обойтись совсем без циклических конструкций, можно написать рекурсивный вариант того же самого:

Function map(f, a) { if (a.length === 0) { return ; } return .concat(map(f, a.slice(1))); }
Рекурсивное решение выглядит весьма элегантно. Всего пара строчек кода и минимум отступов. Но рекурсивные реализации алгоритмов обычно используют с большой осторожностью, кроме того, они отличаются плохой производительностью в старых браузерах. И, на самом деле, нам совершено не нужно самим писать функцию реализации операции отображения, если только на то нет веской причины. То, что делает наша функция map – задача настолько распространённая, что в JavaScript имеется встроенный метод map() . Если воспользоваться этим методом, код окажется вот таким:

Let bandoodle = band.map(oodlify); let floodleship = fellowship.map(oodlify); let bandizzle = band.map(izzlify); let fellowshizzle = fellowship.map(izzlify);
Обратите внимание на то, что здесь вообще нет ни отступов, ни циклов. Конечно, при обработке данных, где-то в недрах JavaScript, могут использоваться циклы, но это уже – не наша забота. Теперь код получился и сжатым, и выразительным. Кроме того, он проще.

Почему этот код проще? Может показаться, что вопрос это глупый, но подумайте об этом. Он проще потому что он короче? Нет. Компактность кода – это не признак простоты. Он проще потому что при таком подходе мы разбили задачу на части. А именно, есть две функции, которые работают со строками: oodlify и izzlify . Эти функции не должны ничего знать о массивах или о циклах. Имеется ещё одна функция – map , которая работает с массивами. При этом ей совершенно безразлично, какого типа данные в массиве, или то, что именно мы хотим с этими данными делать. Она просто исполняет любую переданную ей функцию, передавая ей элементы массива. Вместо того, чтобы всё смешивать, мы разделили обработку строк и обработку массивов. Именно поэтому итоговый код оказался проще.

Свёртка массивов

Итак, функция map весьма полезна, но она не перекрывает все варианты обработки массивов, в которых используются циклы. Она хороша в случаях, когда на основе некоего массива нужно создать новый, имеющий ту же длину. Но что, если нам нужно, например, сложить все элементы числового массива? Или, если надо найти самую короткую строку в списке? Иногда требуется обработать массив и, фактически, сформировать на его основе одно значение.

Рассмотрим пример. Предположим, имеется список объектов, каждый из которых представляет супергероя:

Const heroes = [ {name: "Hulk", strength: 90000}, {name: "Spider-Man", strength: 25000}, {name: "Hawk Eye", strength: 136}, {name: "Thor", strength: 100000}, {name: "Black Widow", strength: 136}, {name: "Vision", strength: 5000}, {name: "Scarlet Witch", strength: 60}, {name: "Mystique", strength: 120}, {name: "Namora", strength: 75000}, ];
Надо найти самого сильного героя. Для того, чтобы это сделать, можно воспользоваться циклом for…of:

Let strongest = {strength: 0}; for (let hero of heroes) { if (hero.strength > strongest.strength) { strongest = hero; } }
Учитывая все обстоятельства, этот код не так уж и плох. Мы обходим в цикле массив, храня объект самого сильного из просмотренных героев в переменной strongest . Для того, чтобы яснее увидеть шаблон работы с массивом, представим, что ещё надо выяснить общую силу всех героев.

Let combinedStrength = 0; for (let hero of heroes) { combinedStrength += hero.strength; }
В каждом из этих двух примеров имеется рабочая переменная, которую инициализируют перед запуском цикла. Затем, в каждой итерации, обрабатывают один элемент массива и обновляют переменную. Для того, чтобы выделить схему работы ещё лучше, вынесем операции, выполняемые внутри циклов, в функции, и переименуем переменные для того, чтобы подчеркнуть схожесть производимых действий.

Function greaterStrength(champion, contender) { return (contender.strength > champion.strength) ? contender: champion; } function addStrength(tally, hero) { return tally + hero.strength; } const initialStrongest = {strength: 0}; let working = initialStrongest; for (hero of heroes) { working = greaterStrength(working, hero); } const strongest = working; const initialCombinedStrength = 0; working = initialCombinedStrength; for (hero of heroes) { working = addStrength(working, hero); } const combinedStrength = working;
Если всё переписано так, как показано выше, два цикла оказываются очень похожими. Единственное, что их отличает – это вызываемые в них функции и начальные значения переменных. В обоих циклах массив сворачивается до одного значения. В англоязычной терминологии такая операция называется «reducing». Поэтому создадим функцию reduce , реализующую обнаруженный шаблон.

Function reduce(f, initialVal, a) { let working = initialVal; for (let item of a) { working = f(working, item); } return working; }
Надо отметить, что, как и в случае с шаблоном функции map , шаблон функции reduce распространён так широко, что JavaScript предоставляет его в качестве встроенного метода массивов. Поэтому свой метод, если на это нет особой причины, писать не нужно. С использованием стандартного метода код будет выглядеть так:

Const strongestHero = heroes.reduce(greaterStrength, {strength: 0}); const combinedStrength = heroes.reduce(addStrength, 0);
Если присмотреться к итоговому результату, можно обнаружить, что получившийся код ненамного короче того, что был раньше, экономия совсем невелика. Если бы мы использовали функцию reduce , написанную самостоятельно, то, в целом, код получился бы больше. Однако, наша цель заключается не в том, чтобы писать короткий код, а в том, чтобы уменьшать его сложность. Итак, уменьшили ли мы сложность программы? Могу утверждать, что уменьшили. Мы отделили код циклов от кода, который обрабатывает элементы массива. В результате отдельные участки программы стали более независимыми. Код получился проще.

На первый взгляд функция reduce может показаться довольно примитивной. В большинстве примеров использования этой функции демонстрируются простые вещи, вроде сложения всех элементов числовых массивов. Однако, нигде не сказано, что значение, которое возвращает reduce , должно быть примитивным типом. Это может быть объект или даже другой массив. Когда я впервые это понял, это меня поразило. Можно, например, написать реализацию операции отображения или фильтрации массива с использованием reduce . Предлагаю вам самим это попробовать.

Фильтрация массивов

Итак, имеется функция map для выполнения операций над каждым элементом массива. Есть функция reduce , которая позволяет сжать массив до единственного значения. Но что, если нужно извлечь из массива лишь некоторые его элементы? Для того, чтобы эту идею исследовать, расширим список супергероев, добавим туда некоторые дополнительные данные:

Const heroes = [ {name: "Hulk", strength: 90000, sex: "m"}, {name: "Spider-Man", strength: 25000, sex: "m"}, {name: "Hawk Eye", strength: 136, sex: "m"}, {name: "Thor", strength: 100000, sex: "m"}, {name: "Black Widow", strength: 136, sex: "f"}, {name: "Vision", strength: 5000, sex: "m"}, {name: "Scarlet Witch", strength: 60, sex: "f"}, {name: "Mystique", strength: 120, sex: "f"}, {name: "Namora", strength: 75000, sex: "f"}, ];
Теперь предположим, что имеется две задачи:

1. Найти всех героев-женщин.
2. Найти всех героев, сила которых превышает 500.

К решению этих задач вполне можно подойти, используя старый добрый цикл for…of:

Let femaleHeroes = ; for (let hero of heroes) { if (hero.sex === "f") { femaleHeroes.push(hero); } } let superhumans = ; for (let hero of heroes) { if (hero.strength >= 500) { superhumans.push(hero); } }
В общем-то, выглядит это вполне пристойно. Но тут невооруженным глазом виден повторяющийся шаблон. На самом деле, циклы совершенно одинаковые, различаются они только блоками if . Что если вынести эти блоки в функции?

Function isFemaleHero(hero) { return (hero.sex === "f"); } function isSuperhuman(hero) { return (hero.strength >= 500); } let femaleHeroes = ; for (let hero of heroes) { if (isFemaleHero(hero)) { femaleHeroes.push(hero); } } let superhumans = ; for (let hero of heroes) { if (isSuperhuman(hero)) { superhumans.push(hero); } }
Функции, которые возвращают только true или false иногда называют предикатами. Мы используем предикат для принятия решения о том, надо ли сохранить в новом массиве очередное значение из массива heroes .

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

Function filter(predicate, arr) { let working = ; for (let item of arr) { if (predicate(item)) { working = working.concat(item); } } return working; } const femaleHeroes = filter(isFemaleHero, heroes); const superhumans = filter(isSuperhuman, heroes);
Здесь, как и в случае со встроенными функциями map и reduce , в JavaScript имеется то же самое, что мы тут написали, в виде стандартного метода filter объекта Array . Поэтому писать собственную функцию, без явной необходимости, не нужно. С использованием стандартных средств код будет выглядеть так:

Const femaleHeroes = heroes.filter(isFemaleHero); const superhumans = heroes.filter(isSuperhuman);
Почему такой подход гораздо лучше, чем использование цикла for…of ? Подумайте о том, как этим можно воспользоваться на практике. У нас имеется задача вида: «Найти всех героев, которые…». Как только выяснилось, что можно решить задачу с использованием стандартной функции filter , работа упрощается. Всё, что нужно – сообщить этой функции, какие именно элементы нас интересуют. Делается это через написание одной компактной функции. Не нужно заботиться ни об обработке массивов, ни о дополнительных переменных. Вместо этого мы пишем крошечную функцию-предикат и задача решена.

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

Поиск в массивах

Фильтрация – весьма полезная операция. Но что, если надо найти лишь одного супергероя из списка? Скажем, нас интересует Black Widow. Функцию filter вполне можно использовать для решения этой задачи:

Function isBlackWidow(hero) { return (hero.name === "Black Widow"); } const blackWidow = heroes.filter(isBlackWidow);
Главная проблема тут заключается в том, что подобное решение не отличается эффективностью. Метод filter просматривает каждый элемент массива. Однако, известно, что в массиве лишь одного героя зовут Black Widow, а это значит, что можно остановиться после того, как этот герой найден. В то же время, функциями-предикатами удобно пользоваться. Поэтому напишем функцию find , которая найдёт и вернёт первый подходящий элемент:

Function find(predicate, arr) { for (let item of arr) { if (predicate(item)) { return item; } } } const blackWidow = find(isBlackWidow, heroes);
Тут, опять же, надо сказать, что в JavaScript есть встроенная функция, которая делает в точности то, что нужно:

Const blackWidow = heroes.find(isBlackWidow);
В итоге, как и прежде, удалось выразить нашу идею более сжато. С использованием встроенной функции find , задача поиска определённого элемента сводится к одному вопросу: «По какому признаку можно определить, что искомый элемент обнаружен?» При этом не надо беспокоиться о деталях.

О функциях reduce и filter

Читатели заметили, что неэффективно дважды проходиться по списку героев в вышеприведённых примерах к функциям reduce и filter . Использование оператора расширения (spread operator) из ES2015 позволяет удобно скомбинировать две функции, занятых свёрткой массива, в одну. Вот изменённый фрагмент кода, который позволяет проходиться по массиву лишь один раз:

Function processStrength({strongestHero, combinedStrength}, hero) { return { strongestHero: greaterStrength(strongestHero, hero), combinedStrength: addStrength(combinedStrength, hero), }; } const {strongestHero, combinedStrength} = heroes.reduce(processStrength, {strongestHero: {strength: 0}, combinedStrength: 0});
Не могу не заметить, что эта версия будет немного сложнее, чем та, в которой по массиву проходились дважды, но, если массив огромен, сокращение числа проходов по нему может оказаться весьма кстати. В любом случае, порядок сложности алгоритма остаётся O(n).

Итоги

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

1. Мы избавляемся от циклов, что делает код более сжатым и, скорее всего, более лёгким для чтения.
2. Используемый шаблон описывается с использованием подходящего имени стандартного метода. То есть – map , reduce , filter , или find .
3. Масштаб задачи уменьшается. Вместо самостоятельного написания кода для обработки массива, нужно лишь указать стандартной функции на то, что надо с массивом сделать.

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

На самом деле, если обо всём этом задуматься, можно прийти к выводу, который, в первый момент, кажется удивительным. Оказывается, если использовать лишь четыре вышеописанных шаблона обработки массивов, можно убрать из JS-кода практически все циклы. Ведь что делается в практически каждом цикле, написанном на JavaScript? В нём либо обрабатывается, либо конструируется некий массив, либо делается и то и другое. Кроме того, в JS есть и другие стандартные функции для работы с массивами, вы вполне можете изучить их самостоятельно. Избавление от циклов практически всегда позволяет уменьшить сложность программ и писать код, который легче читать и поддерживать.

Уважаемые JavaScript-разработчики, а у вас на примете есть стандартные функции, которые позволяют улучшить код, избавившись от каких-нибудь распространённых «самописных» конструкций?

Теги: Добавить метки

Основная цель в JavaScript while — повторно запускать определенный фрагмент кода, снова и снова. Он очень похож на цикл for с одним важным отличием. Позвольте мне занять немного вашего времени, чтобы объяснить разницу между этими двумя типами циклов.

В чем разница между циклами while и for?

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

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

В while все происходит по-другому. Цикл while JavaScript выполняется, пока истинно определенное условие. После того, как условие расценивается как ложное, тогда цикл while прекращается.

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

Плюсы и минусы цикла while

Позвольте мне начать с рассмотрения единственного существенного «минуса » цикла while . Он может работать вечно!

Если окажетесь в ситуации, когда цикл while продолжит выполняться до бесконечности, то ваша программа застрянет (или зависнет ). Тогда нужно закрыть браузер, чтобы прервать выполнение кода JavaScript .

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

Теперь относительно «плюсов » — они весьма очевидны. While будет непрерывно работать до тех пор, пока выполняется условие. В качестве примера использования цикла while можно привести запрос к пользователю ввести данные. Цикл будет предлагать ввести данные снова и снова, пока пользователь не введет корректные данные.

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

Синтаксис циклов for и while очень похож.

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

Вот, как должен выглядеть код:

while () { // вставьте сюда код, который должен выполняться циклично }

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

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

Пример цикла while

Предположим, что мы хотим попросить пользователя ввести число от 1 до 10. Но что произойдет, если он введет неправильное число?

В этом случае мы должны попросить его снова ввести значение, и проверить, соблюдено ли условие (введено ли число от 1 до 10 ).

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

Вот как может выглядеть наш код:

var theNumber = prompt("Пожалуйста, введите число от 1 до 10."); while (theNumber < 1 || theNumber > 10 || isNaN(theNumber)) { theNumber = prompt("Введено неправильное значение, пожалуйста, введите число от 1 до 10!"); } alert("Отлично! Вы ввели число: " + theNumber);

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

Вот эти три условия: theNumber 10 || isNaN(theNumber) . Они указывают следующее:

• ЕСЛИ theNumber меньше 1, ИЛИ;
• ЕСЛИ theNumber больше 10, ИЛИ;
• ЕСЛИ theNumber — это НЕ число, то продолжить цикл.

Так как мы используем оператор ИЛИ (||) между всеми условиями, это означает, что если любое из условий истинно, то общее условие цикла while будет оценено как true, и выполнение цикла будет продолжено.

Только в том случае, если все три условия оцениваются как false , общее условие цикла while будет оценено, как false , и он будет остановлен.

Заключение

JavaScript while loop является единственным реальным циклом в языках программирования. for является просто частной разновидностью цикла while .

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

var counter = 0; while (counter < 10) { counter = counter + 1; console.log("The counter is currently at: " + counter); }

Код будет повторяться ровно 10 раз, не больше и не меньше. Это в точности так, работает цикл for .

Не нужно бояться использовать JavaScript while . Так как без него множество приложений просто не работали бы должным образом!

Я надеюсь, вам понравилась эта статья.

Перевод статьи «While Loop in JavaScript » был подготовлен дружной командой проекта .

Хорошо Плохо