Если вы новичок в этой серии, начните с здесь.

Предыдущее сообщение, Часть 8, находится здесь

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

Допустим, я хочу напечатать все числа от 1 до 10. Тогда стандартный способ написания кода — это println(1), println(2)… и т.д. является повторяющейся задачей. В программировании мы не повторяем наш код. Вот почему вводятся циклы, чтобы сделать программу менее сложной с минимальным количеством строк кода.

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

Чтобы использовать циклы в Kotlin, у нас есть два разных способа, которые распространены почти во всех языках программирования:

  • Цикл for
  • Цикл пока
  • Цикл do-while

Цикл for

Типичный синтаксис цикла for выглядит следующим образом:

for (<element> in <a collection>){
          loop body
}

Теперь я буду использовать ключевое слово until для вывода чисел от 0 до 10, то есть от 0 до 9. Код выглядит следующим образом:

fun main(){

    for (element in 0 until 10){
        println(element)
    }
}

Значение, которое мы получаем после каждой итерации, сохраняется в переменной. В приведенном выше случае значение итерации сохраняется в переменной element.

Вы можете видеть, что числа были напечатаны от 0 до 9, потому что я использовал до 10. Здесь верхняя граница 10 не включена. Таким образом, как только итератор достигает значения 10 в element, он останавливается.

Диапазон — это интервал значений, определяемый парой точек (начальной и конечной). Синтаксис диапазона следующий:

начальная точка .. конечная точка

Теперь я запущу тот же цикл for, используя диапазон-

fun main(){

    for (element in 0..10){
        println(element)
    }
}

Обратите внимание на одну вещь в выводе: мы видим, что 10 также печатается, в отличие от использования ключевого слова until в предыдущем коде. Это связано с тем, что конечная точка включается, когда мы используем диапазон в Kotlin. Чтобы исключить конечную точку, просто уменьшите ее на единицу.

То же самое может быть достигнуто с помощью функции rangeTo(), подобной этой:

fun main(){

    for (element in 0.rangeTo(10)){
        println(element)
    }
}

Так что просто запомни это-

until исключает конечную точку (верхнюю границу), а диапазон включает конечную точку.

Пример 1

fun main(){

    for (element in 10 downTo 0){
        println(element)
    }
}

Ключевое слово downTo используется для изменения диапазона. В результате приведенный выше код печатает числа от 10 до 0.

Пример 2

Что сделало ключевое слово downTo, функция с именем reversed() может сделать то же самое.

fun main(){

    for (element in (0..10).reversed()){
        println(element)
    }
}

Обратите внимание на формат, в котором написан код…😠

Пример №3

fun main(){

    for (element in 0 .. 10 step 2){
        println(element)
    }
}

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

Пример №4

fun main(){

    repeat (2) {
        println("Kotlin")
    }
}

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

Пример №5

fun main(){

    var sum = 0
    for (x in 1..100){

        sum += x
    }

    print("Sum of the numbers from 1 to 100 is $sum")
}

Здесь я инициализировал переменную суммы, в которой я буду хранить сумму чисел. Внутри цикла for устанавливается диапазон от 1 до 100, и с каждой итерацией x получает значение, которое добавляется к sum переменная (которая в коде - sum += x в теле цикла). Наконец, я вышел из цикла (то есть за фигурные скобки цикла for) и напечатал сумму.

Когда использовать для цикла

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

Цикл while

Типичный синтаксис цикла while выглядит следующим образом:

while (until condition is true){
      execute loop body
         ...
         ...
      increment/decrement to make the condition false
}

Все, что возможно в цикле for, возможно и в цикле while.

fun main(){

    var x = 0
    var sum = 0

    while (x <= 100){
        sum += x
        x++
    }
    print("Sum of the numbers from 1 to 100 is $sum")
}

В приведенном выше коде я инициализировал две переменные, а именно x и sum.

x предназначен для использования в цикле while, а sum — для хранения суммы чисел от 1 до 100.

Чтобы заставить x продвигаться вперед на один шаг в каждой итерации, я установил условие приращения как- x++ в конце тела цикла, чтобы при через одну точку он пересечет конечную точку, т. е. 100. В этот самый момент цикл остановится, а программный курсор выйдет из цикла и напечатает сумму в виде результат.

Моя задача для вас: попрактиковаться в создании примеров программ, таких как:

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

Когда использовать цикл while

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

Цикл do-while

Тот же цикл while можно представить по-другому, используя цикл Kotlin do-while.

Типичный синтаксис цикла do-while выглядит следующим образом:

do {
   loop body
}while (condition holds true)

fun main(){

    var x = 0
    var sum = 0

    do {
        sum += x
        x++
    }while (x <= 100)

    print("Sum of the numbers from 1 to 100 is $sum")
}

Основное различие между циклами while и do-while заключается в следующем.

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

Заявление о перерыве

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

fun main(){

    var x = 0

    while (x++ <= 100){
        println(x)

        if (x == 10){
            break
        }
    }
}

В приведенном выше коде я хотел напечатать все значения x до 100. Но мое условие состоит в том, что если в любой момент времени x становится равным 10, затем завершает цикл. Итак, вывод должен быть таким:

Оператор continue

Ключевое слово Continue пропускает текущую итерацию и переходит к следующей итерации в цикле.

fun main(){

    var x = 0

    while (x++ < 5){
        if (x == 3){
            continue
        }
        println(x)
    }
}

Операторы после continue не будут выполняться для этой конкретной итерации. Вот почему я поместил оператор печати после continue. Это напечатает все значения от 1 до 5, но без 3. Таким образом, вывод будет:

Ключевое слово в

В приведенных выше статьях вы, должно быть, заметили, что мы использовали оператор in при использовании циклов for, т. е. для элемента in диапазон, сделай это...

Тот же самый оператор in можно использовать для проверки принадлежности элемента к такому диапазону:

fun main(){
    val x = 1..100
    val y = 10
    if (y in x){
        print("Yes, $y is present in the range $x")
    }
    else{
        print("$y is not present in the range $x")
    }
}

Как видите, я использовал оператор in внутри условия if, чтобы проверить, соответствует ли значение y =10 присутствует в диапазоне или нет.

Мы также можем использовать оператор not в сочетании с оператором in, чтобы проверить, отсутствует ли значение в диапазоне, списке и т. д. Использование оператора !in синтаксис.

Это все о циклах в Котлине. Фу… 😮‍💨

→ Продолжить путешествие к Часть 10

Спасибо, что прочитали…

✍️Аджит Кумар Саху