Циклы while..do и for..to

Цикл while...do

Конструкция while...do представляет цикл, который выполняет некоторые действия, пока истинно определенное условие. Эта конструкция имеет следующее формальное определение:

while условие do
    действия

После оператора while идет условие. Это любое выражение, которое возвращает true или false. И пока это условие истинно, то есть возвращает true, будут выполняться выражения, указанные после оператора do.

Например, выведем на консоль через конструкцию while числа от 1 до 9:

let mutable n = 1

while n < 10 do 
    printfn $"{n}"
    n <- n + 1

Здесь вначале определяем переменную n, которая равна 1. Далее в конструкции while указываем условие n < 10. И пока переменная n меньше 10, выполняем действия после оператора do. В частности, выводим на консоль значение переменной n и затем увеличиваем его на единицу.

Причем если конструкция while...do является многострочной, то выражения на второй и последующих строках предваряются отступом.

Таким образом, вначале конструкция while видит, что условие n < 10 возвращает true, и поэтому выполняет выражения после оператора do, что приведет к увеличению переменной n на единицу. Каждое такое одиночное выполнение цикла называется итерацией.

Затем конструкция while опять видит, что условие n < 10 возвращает true (n = 2), и поэтому опять выполняет выражения после оператора do. И так далее, пока значение переменной n не станет равным 10. Когда n станет равной 10, соответственно условие n < 10 возвратит false, и конструкция while...do закончит свою работу. Таким образом, в данном случае будет выполнено 9 итераций.

Одни циклы могут быть вложенными в другие. Например, выведем на консоль таблицу умножения:

let mutable m = 1
let mutable n = 1
while m < 10 do 
    while n < 10 do 
        printf $"{m * n}\t"
        n <- n + 1
    printfn ""
    m <- m + 1
    n <- 1

В данном случае для обоих циклов определяем две переменных n и m. Внешний цикл while m < 10 do работает, пока переменная m не достигнет 10.

Затем во внешнем цикле определяем внутренний цикл while n < 10 do , который выполняется, пока переменная n не станет равной 10. Во внутреннем цикле выводим на консоль произведение значений m и n и затем увеличиваем значение переменной n. Когда n станет равной 10, внутренний цикл завершит работу.

После этого продолжится работа внешнего цикла, в котором переводим курсор на следующую строку printfn "". Увеличиваем значение переменной m и сбрасываем значение переменной n до 1, чтобы при новом значении m внутренний цикл заново выполнялся.

for...to

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

for идентификатор = начальное_значение [ to | downto ] конечное_значение do
    действия

После оператора for идет название переменной, которой передается некоторое начальное значение.

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

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

Если применяется оператор downto, то цикл for, наоборот, последовательно уменьшает значение переменной от начального до конечного на единицу.

Причем и начальное и конечное значения должны представлять тип int.

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

Если конструкция for...do, то выражения второй и последующих строк предваряются отступом.

Например, выведем на консоль числа с 1 до 5 включительно:

for i = 1 to 5 do printfn $"i = {i}"

Здесь цикл for определяет переменную i, которой в качестве начального значения присваивается 1. Конечное значение - 5. Оператор to указывает, что с каждой итерацией значение переменной i будет увеличиваться на единицу от 1 до 5. То есть цикл будет выполняться пять раз.

Для каждого значения переменной от 1 до 5 будет выполняться выражение printfn $"i = {i}".

Таким образом, мы получим следующий консольный вывод:

i = 1
i = 2
i = 3
i = 4
i = 5

Заменив оператор to на downto, мы можем выполнить перебор значений в обратном порядке:

for i = 5 downto 1 do printfn $"i = {i}"

i = 5
i = 4
i = 3
i = 2
i = 1

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

for m = 1 to 9 do
    for n = 1 to 9 do
        printf $"{m * n}\t"
    printfn ""

for...in

Конструкция for...in применяется для перебора набора или коллекций значений. Она имеет следующее формальное определение:

for значение in коллекция_элементов do
    действия

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

for n in 1..6 do printf $"{n}"

Здесь с помощью выражения 1..6 генерируется последовательность чисел от 1 до 6. (Последовательности и вообще коллекции будут подробнее рассмотрены далее.)

При переборе этой последовательности каждый ее элемент передается в n. То есть в n последовательно окажутся числа от 1 до 6.

После do идут действия, выполняемые над этим значением. В данном случае это вывод элемента последовательности на консоль.

Таким образом, цикл отработает 6 раз (то есть выполнит 6 итераций), и на консоль будет выведена вереница чисел от 1 до 6:

1 2 3 4 5 6

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

for _ in 1..5 do printfn $"Hello"

В данном случае на консоль просто пять раз выводится строка "Hello". И поскольку нам перебираемые элементы не важны, то вместо названия значения указываем прочерк.

Также можно включать одни циклы в другие. Например, выведем таблицу умножения.

for m in 1..9 do 
    for n in 1..9 do 
        printf $"{n * m} \t"
    printfn ""