В прошлом уроке мы изучали условные операторы, которые позволяют выполнить определенные инструкции при соблюдение некоторого условия. В этом уроке мы узнаем как выполнить инструкцию, или инструкции несколько раз. Для этого нам помогут операторы-циклы. Их всего 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. Переменная a теперь не проходит это условие и на этом цикл заканчивается. Если вы хотите, чтобы массив заполнился до 10, то можете поменять местами эти две инструкции.
Тогда и a будет равна 10 и массив заполнится до 10.
А что будет если мы забудем написать эту строку. Тогда a всегда будет равен 0, и цикл станет бесконечным, так как 0 всегда будет меньше 10, и транслятор постоянно будет присваивать порядковому номеру 0 массива b значение ноль. Такой бесконечный цикл очень нагружает процессор, браузер станет тормозить, так что я даже запускать этот код не хочу.
Как вы могли заметить, наш цикл while тесно связан с переменной a, и чтобы цикл нормально работал, нам нужны три выражения, первое выражение, где мы объявляем переменную a называется инициализацией, выражение которое находится в скобках называется проверкой, строка кода, где мы увеличиваем значение переменной называется инкрементирование.
Итак, чтобы цикл while, так же как и do while нормально работал, должны присутствовать в коде три выражения с переменой a: инициализация, проверка и инкрементирование. Если мы забудем про инкрементирование, то транслятор не выдаст ошибку и цикл станет бесконечным.
Теперь перейдем к циклу for. Почему я сказал, что цикл for более безопасный. Дело в том что все эти три выражения необходимые для цикла в цикле for пишутся подряд в одних скобках. Итак давайте теперь напишем этот код, только с помощью for.
Вначале объявим массив
Затем пишем ключевое слово for и в скобках сперва набираем выражение инициализации, затем ставим точку с запятой (так как цикл for воспринимает их как инструкции), затем пишем проверку, и потом инкрементирование. Далее в фигурных скобках пишем код который будет добавлять новые значения массиву.
Запускаем. Консоль вернула значение 9, т.е. мы можем сказать, что массив заполнился до 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.
