11. Циклы

В прошлом уроке мы изучали условные операторы, которые позволяли выполнить некоторый код при выполнении определенного условия. А что если нам надо при выполнении определенного условия выполнить код необходимое количество раз. Т.е. не один раз как с условными операторами, а несколько раз. Для этого нам помогут операторы-циклы. Их всего 5:
while
do while
for
for in
for of

Начнем с изучения цикла while. Сначала создадим переменную и присвоим ей значение.

По написанию цикл while похож на условный оператор if. Вначале мы пишем ключевое слово while, которое также является и оператором, затем нам надо поставить круглые скобки внутри них будет выражение, которое должно вернуть либо true либо false. Например, i<10. Далее мы можем указать фигурные скобки если у нас будет много инструкций, но как я уже говорил, лучше их ставить всегда, даже если у вас одна инструкция.

Теперь если i <10 мы прибавим к переменной a число 1

Нажимаем Enter. Оператор while вернул число 10 это как раз то чему равна переменная a. Давайте убедимся, набираем a. И видим, что переменная a равна 10. Так как же это произошло? Смотрите, вначале мы создали переменную a равной 1. Далее транслятор переходит циклу while, проверяет условие, значение a меньше 10, значит надо выполнить этот код, т.е. прибавить к значению a единицу.

Теперь переменная a равна 2. Далее транслятор снова возвращается к условию, 2 меньше 10, да, значит снова к переменной a прибавляем единицу, и так до тех пор пока переменная a не будет равна десяти. Когда переменная a будет равна 10 условие в скобках вернет false, так теперь a не меньше 10, и на этом цикл закончится, а транслятор пойдет дальше выполнять остальной код программы, которого в нашем случае нет.

Кстати, эту запись можно сократить с помощью операторов присваивания. Из операторов присваивания мы знаем пока только простой оператор присваивания который имеет знак =.

Также есть оператор с умножением *=

с делением /=

Оператор присваивания с взятием остатка от деления. %=

присваивание со сложением сложением +=

и с вычитанием -=
Есть еще операторы присваивания, но пока на данном этапе этих нам достаточно.

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

Т.е. оператор присваивания со сложением прибавляет число, в нашем случае единицу, к значению переменной a, а затем получившийся результат присваивает переменной a. Как видите, вернулось число 10, т.е. переменная a равна 10.

А если мы напишем так:

То транслятор создаст переменную a со значением 10, увидит что выражение в скобках выдает false, и просто проигнорирует код в фигурных скобках. Как бы все понятно, но что если нам надо хотя бы один раз выполнить код находящийся в фигурных скобках, даже если выражение в круглых скобках сразу выдаст false. Здесь на помощь придет второй вид циклов это do while, пишется он так.

Нажимаем Enter. И как видите a нас равно 11. Т.е. цикл do while по-любому выполнит код в фигурных хотя бы один раз, даже если условие изначально выдаст false. А во всем остальном он работает также как цикл while. Т.е. если мы напишем так:

То переменная a будет иметь значение 10. Т.е. главное отличие do while от while заключается в том, что код в do while обязательно выполнится хотя бы один раз.

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

Сначала создадим две переменные, сперва переменную a но теперь со значением 0, а второй переменной будет массив, в который мы должны записать значения от 0 до 9

Пишем цикл while, условие, далее пишем массив, в квадратных скобках пишем порядковый номер куда мы будем записывать значение, далее знак равно и само значение. Получается в порядковом номере 0 у массива b будет хранится значение 0, в порядковом номере 1 будет значение 1 и так до 9. Следующая инструкция будет прибавлять к значению переменной a число 1 и присваивать получившееся значение соответственно переменной a.

Нажимаем Enter, и когда у нас несколько инструкций в фигурных скобках, то транслятор вернет в консоль результат последнего выражения, а последнее выражение у нас это a+=1, что и вернет нам 10 в заключительной итерации (итерация означает повторение. И часто программисты вместо слова повторение кода, говорят именно итерация кода).

Вы можете спросить, а почему переменная a после цикла становится равной 10, а массив заполняется до 9? Здесь все просто, когда переменная равна 9, то проверка возвращает true, значение 9 записывается сюда и сюда, и затем к переменной a прибавляется 1, и теперь a содержит 10. На этом цикл заканчивается. Если вы хотите, чтобы массив заполнился до 10, то можете поменять местами эти две инструкции.

Тогда и a будет равна 10 и массив заполнится до 10.

А что будет если мы забудем написать эту строку. Тогда a всегда будет равен 0, и цикл станет бесконечным, так как 0 всегда будет меньше 10, и постоянно транслятор будет присваивать порядковому номеру 0 массива b значение ноль. И такой бесконечный цикл очень нагружает процессор, браузер станет тормозить, так что я даже запускать этот код не хочу.

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

Итак, чтобы цикл while, так же как и do while нормально работал, должны присутствовать в коде три выражения с переменой a: инициализация, проверка и инкрементирование. Если мы забудем про инкрементирование, то транслятор не выдаст ошибку и цикл станет бесконечным.

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

Вначале объявим массив

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

Запускаем. Консоль вернула значение 9, это значение данного выражения в последней итерации (в цикле while у нас последнее выражение было a+=1, и консоль возвращала результат именно этого выражения), т.е. мы можем сказать, что массив заполнился до 9.

Как работает цикл for? он сперва обращается к инициализации, затем переходит к проверке, если проверка возвращает true, то транслятор переходит к выполнению кода в скобках, выполнив его, он перемещается к инкрементированию, затем снова к проверке и т.д. пока проверка не вернет false.

Также обычно в выражении инкрементировании не пользуются обычно оператором присваивания со сложение, а гораздо чаще пользуются унарным оператором ++. Он делает тоже самое, прибавляет к значению переменой единицу и присваивает получившееся значение переменной a. До этого момента мы с вами изучали бинарные арифметические операторы, т.е. операторы которым нужны два операнда. Унарным операторам нужен только один операнд и вот их список. В этом уроке мы пока изучим унарные операторы +, -, а также ++ и — которых также называют инкремент и декремент соответственно.

В приоритете операторов унарные операторы занимают довольно высокое место:

доступ к свойствам . []
операнд++, операнд–
+операнд, -операнд, ++операнд, –операнд

**
умножение деление остаток от деления
сложение вычитание
< > <= >=
операторы равенства и неравентсва
лоическое И
Логическое ИЛИ
ОПЕРАТОРЫ ПРИСВАИВАНИЯ
ЗАПЯТАЯ

Как видите, в зависимости от того где вы указываете унарный оператор ++ или –, перед операндом или после, зависит его приоритет. Унарные операторы + – ставятся только перед операндом. А в чем же различие если мы слева от операнда поставим например ++, или справа. Как мы поняли, у этих операторов будет разный приоритет. Ну а что же еще, почему оставили возможность слева и справа писать от операнда эти операторы.

Дело в том что когда мы пишем оператор ++ перед операндом, то транслятор сперва вычисляет значение, а потом его выводит. Например:

Ну а если мы теперь напишем так:

То транслятор сперва выводит значение x, а потом вычислят, т.е. прибавляет. Как видите, мы снова получили 11, но если написать переменную x, то теперь она равна 12. Вот и все отличие. Для цикла for без разницы, где мы используем ++ или –, так как он значение этого выражения не выводит в консоль. Напишем так:

или так:

Результат не поменяется. Но с циклом while все не так просто. Давайте снова воспользуемся циклом while

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

Как видите, у нас в последней итерации, сперва вывелось значение переменной a, а потом уже к этому значению прибавилось 1 и результат присвоился переменной a. Если мы выведем значение a то оно будет равно 10. И на массив это никак не влияет, так как сперва вывелось значение 9, затем переменной a присвоилось значение 10, это значение переменной не прошло проверку и цикл остановился.

Кстати, когда мы пишем ++ перед операндом то тот оператор называется префиксным инкрементом, а если — то префиксным декрементом. ++ и — которые пишутся после операнда называются постфиксным инкрементом и декрементом. В циклах for, while и do/while мы можем использовать не только выражение инкрементирование, но и декрементирование.

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

Переходим к следующему циклу – это for of. На самом деле это усеченная форма цикла for предназначенная для работы в основном с массивами. Допустим мы создали такой массив:

Теперь мы хотим узнать чему будет равна сумма всех чисел массива. Для этого создадим переменную sum со значением 0, далее набираем ключевое слово for

В скобках сперва создаем переменную, название пусть будет снова a, далее пишем of и указываем массив, ставим фигурные скобки. Теперь каждую итерацию переменная a будет равна одному из значений массива начиная с порядкового номера 0 и до конца.

В фигурных скобках пишем переменную sum, и дальше с помощью оператора присвоения со сложением используем переменную a. Т.е. в первой итерации a будет равна 24, во второй итерации a будет равна 54 и т.д. И все эти числа будут суммироваться в переменной sum.
Нажимаем Enter и sum равна 340.

Осталось рассмотреть цикл for in. Он похож на for of и предназначен для работы уже с объектами. Если переменная в for of копировала каждое значение массива, то переменная в for in копирует сам ключ объекта, но не его значение. Допустим у нас есть такой объект:

Теперь мы хотим передать все значения этого объекта массиву. Создадим пустой массив и переменную с именем pos, т.е. позиция со значением 0.

Теперь пишем ключевое слово for, так как переменная копирует названия ключей, то так её и назовем key. Далее пишем слово in и наш объект.

Далее в фигурных скобках указываем массив, его порядковый номер, обязательно используем постфиксный инкремент, чтобы сперва использовалось значение 0, а в следующей итерации 1, 2 и т.д. Затем указываем равно, пишем объект Car и в квадратных скобках его ключ.

Нажимаем Enter и наш массив скопировал все значения объекта. Если мы хотим скопировать в массив только ключи, то мы можем сильно сократить эту запись. Дело в том что мы не обязаны создавать новую переменную в скобках, а можем пользоваться уже созданной, например нашим массивом. Пишем массив, квадратные скобки, порядковый номер также указываем через переменную pos и постфиксным инкрементом и все, дальнейшие действия нам не нужны, каждую итерацию очередной ключ объекта будет записываться как новое значение для массива.

Домашнее задание.

Создайте пустой массив arr, далее создайте переменную с именем pos и присвойте ей число 0. Теперь с помощью цикла for присвойте только четные значения массиву arr. Т.е. в позиции 0 у массива должно быть значение 2, в позиции 1 значение 4 и так далее до значения 100.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *