Циклы позволяют выполнять некоторое действие множество раз. В языке Rust имеются следующие виды циклов:
for
while
loop
Цикл loop имеет следующее определение:
loop
{
// выполняемые инструкции
}
После оператора loop указывает блок инструкций, которые выполняются в цикле. Например:
loop{
println!("Hello Rust");
println!("on Metanit.com");
}
Данный цикл выводит на консоль две строки. Стоит отметить, что loop по умолчанию организует бесконечный цикл. То есть определенные выше
в цикле loop две строки будут выводится бесконечное количество раз, пока не будет нажато CTRL+C.
Hello Rust on Metanit.com Hello Rust on Metanit.com Hello Rust on Metanit.com Hello Rust on Metanit.com Hello Rust on Metanit.com ^C
Чтобы организовать выход из цикла, применяется оператор break. В частности, мы можем в цикле при определенном условии вызывать данный оператор и выходить из цикла:
fn main(){
let mut n = 1;
loop{
println!("n = {}", n);
n = n + 1;
if n == 10{
break;
}
}
println!("Конец программы");
}
В данном случае в цикле loop выводится на консоль значение переменной n. Затем это значение увеличивается на единицу.
Когда значение переменной достигнет 10, вызывается оператор break, который выполняет выход из цикла loop.
В итоге мы получим следующий консольный вывод:
n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 9 Конец программы
Цикл loop может возвращать некоторое значение с помощью оператора break.
fn main(){
let mut num = 1;
let result = loop
{
if num == 4 { break num * 2;}
num = num + 1;
};
println!("result = {}", result); // result = 8
}
Возвращаемое значение указывается после оператора break. В данном случае это значение переменной num, умноженное на 2:
break num * 2;
Поскольку данный цикл loop возвращает значение, то мы можем присвоить его результат переменной:
let result = loop { ......... };
Стоит отметить, что в отличие от обычного определения цикла в данном случае после закрывающей фигурной скобки ставится точка с запятой.
В итоге, когда значение переменной num станет равным 4, произойдет выход из цикла, а переменная result в качестве значения получит число
num * 2, то есть 8.
Цикл while выполняет некоторый код, пока его условие истинно, то есть возвращает true.
Он имеет следующее формальное определение:
while условие
{
// выполняемые действия
}
После ключевого слова while идет условное выражение, которое возвращает true или false.
Затем в фигурных скобках идет набор инструкций, которые составляют блок цикла. И пока условие возвращает true, будут выполняться инструкции в
блоке цикла.
Например, перепишем один из предыдущих примеров с циклом loop, только теперь используем цикл while:
fn main(){
let mut n = 1;
while n < 10
{
println!("n = {}", n);
n = n + 1;
}
println!("Конец программы");
}
Здесь пока условие i < 10 истинно, будет выполняться цикл while, в котором выводится на консоль
значение переменной n, после чего оно увеличивается на единицу. В какой-то момент переменная n увеличится до 10, условие n < 10
возвратит false, и цикл завершится.
Цикл for позволяет пройти по всем элементам некоторого набора.
Цикл for имеет следующее формальное определение:
for переменная in набор_элементов
{
// выполняемые действия
}
После ключевого слова for указывается название переменной, которой по очередно будут присваиваться элементы из перебираемого набора. Затем идет ключевое слово in, после которого указывается перебираемый набор.
Таким образом, цикл for проходит по всем элементам набора и поочередно каждый элемент из набора передает в переменную. Например:
fn main(){
for num in 1..6
{
println!("num = {}", num);
}
println!("Конец программы");
}
Итак, в качестве перебираемого набора здесь используется последовательность 1..6. Оператор .. позволяет создать
последовательность значений. Слева от оператора указывается начальный элемент последовательности, а справа - конечный, который не включается в набор.
В данном случае создается последовательность [1, 2, 3, 4, 5].
Цикл for по порядку проходит по каждому элементу из этого набора и передает эти элементы поочередно в переменную num,
которая в цикле выводится на консоль.
В итоге блок цикла for сработает 5 раз:
num = 1 num = 2 num = 3 num = 4 num = 5 Конец программы
Циклы могут быть вложенными. То есть один цикл может содержать другой цикл, а тот еще один цикл и так далее. Например, используем вложенный цикл для вывода таблицы умножения:
fn main(){
let mut i = 1;
let mut j = 1;
while i < 10
{
while j < 10
{
print!("{}\t", i * j);
j = j + 1;
}
println!();
i = i + 1;
j = 1;
}
}
Здесь внешний цикл while срабатывает 9 раз - пока переменная i не станет равна 10. Во внешнем цикле запускается
внутренний цикл while, который также срабатывает 9 раз - пока переменная j не станет равна 10.
Во внутреннем цикле с помощью макроса print!() выводится на консоль результат умножения переменных i и j. В отличие
от println!() макрос print!() не выполняет перевод на следующую строку, а выводит данные на одной строке. Чтобы данные были отделены при выводе,
в строку добавляется табуляция с помощью последовательности "\t".
Консольный вывод:
1 2 3 4 5 6 7 8 9 2 4 6 8 10 12 14 16 18 3 6 9 12 15 18 21 24 27 4 8 12 16 20 24 28 32 36 5 10 15 20 25 30 35 40 45 6 12 18 24 30 36 42 48 54 7 14 21 28 35 42 49 56 63 8 16 24 32 40 48 56 64 72 9 18 27 36 45 54 63 72 81
Аналогичный пример с использованием цикла for:
fn main(){
for i in 1..10
{
for j in 1..10
{
print!("{}\t", i * j);
}
println!();
}
}