Начните свою карьеру программиста на Rust, изучив эти основы языка.

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

Управляющие структуры Rust имеют решающее значение для управления потоком программы, обеспечивая эффективное выполнение кода и упрощение сложных задач до более мелких повторно используемых компонентов.

Условные операторы Rust

Условные операторы — это конструкции, которые позволяют выполнять код на основе условий. Условные операторы удобны для принятия решений, поскольку выполнение программы зависит от того, оценивается ли условие как истинный или ЛОЖЬ. Rust предоставляет если, еще, и соответствовать заявления для принятия решения.

В программах на Rust если оператор проверяет, является ли определенное условие истинным. Если это так, программа запускает соответствующий блок кода. Если условие оценивается как ложное, программа пропускает этот блок кода и переходит к следующему оператору или выполняет

instagram viewer
еще блок операторов, если он есть.

соответствовать Оператор — это мощная конструкция потока управления, которая позволяет программе сопоставлять значения с набором шаблонов и выполнять код на основе шаблона сопоставления.

Операторы if в Rust

Вы объявите если операторы в ваших программах на Rust с если ключевое слово, за которым следует условие:

если состояние {
// код для выполнения, если условие истинно
}

Вот пример того, как вы можете использовать оператор if в своих программах на Rust:

фносновной() {
позволять х = 15;
если х > 10 {
распечатать!("х больше 10");
 }
}

Икс переменная содержит 32-битное целое число, а оператор if проверяет, больше ли значение x десяти, прежде чем запускать блок кода, который его печатает.

Операторы else в Rust

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

если состояние {
// код для выполнения, если условие истинно
} еще {
// код для выполнения, если условие ложно
}

Вот пример, где Икс не превышает 10, т. если оператор оценивает ЛОЖЬ, и еще оператор работает.

фносновной(){
позволять х = 5;
если х > 10 {
распечатать!("х больше 10");
 } еще {
распечатать!("х не больше 10");
 }
}

С Икс равно 5 и 5 не больше 10, программа пропускает если блокирует и выполняет еще блокировать.

Утверждения соответствия Rust

Вы будете использовать соответствовать ключевое слово для принятия сложных решений для проверки ряда шаблонов и выполнения кода на основе совпадений с шаблонами. Операторы соответствия аналогичны операторы переключения в C#, Go и С++.

Вот структура оператора match в Rust:

соответствовать ценить {
 шаблон1 => {
// код для выполнения, если значение соответствует шаблону1
 },
 шаблон2 => {
// код для выполнения, если значение соответствует шаблону2
 },
// и т. д.
}

Вот как вы можете использовать операторы соответствия в своих программах:

позволять класс = 'Б';
соответствовать оценка {
«А» => распечатать!("Отличная работа!"),
'Б' => распечатать!("Хорошая работа."),
'С' => распечатать!(«Вы могли бы сделать лучше».),
 _ => распечатать!(«Это недопустимая оценка».),
}

оценка переменная является символом, а соответствовать Оператор проверяет, какой из символов соответствует значению переменной Grade перед выполнением кода после оператора =>. Вы можете использовать шаблон подчеркивания (_) для сопоставления значений, которые не соответствуют другим шаблонам (шаблон по умолчанию).

Циклы в Rust

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

Циклы while в Rust

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

пока состояние {
// код для выполнения
}

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

Вот пример цикла while в Rust, который печатает числа от одного до пяти.

фносновной() {
позволятьмут я = 1;
пока я <= 5 {
распечатать!("{}", я);
 я += 1;
 }
}

Цикл while в основной функция проходит через числа от одного до пяти, увеличивая я переменная на единицу, пока я переменная больше пяти, где цикл завершается.

Петля Петля

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

петля {
// код для выполнения
если состояние {
перерыв;
 }
}

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

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

фносновной() {
позволятьмут я = 1;
петля {
распечатать!("{}", я);
 я += 1;
если я > 5 {
перерыв;
 }
 }
}

основной функция выполняет цикл, а если оператор увеличивает я переменная. если Оператор указывает завершение цикла, когда я переменная превышает пять.

Rust для циклов

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

для переменная в диапазон {
// код для выполнения
}

диапазон — это выражение, результатом которого является последовательность значений, а переменная — это переменная, которая по очереди принимает каждое значение в последовательности. Блок кода будет выполняться один раз для каждого значения в последовательности.

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

фносновной() {
для я в1..=10 {
распечатать!("{}", я);
 }
}

Цикл перебирает значения от 1 до 10. На каждой итерации переменная (i) содержит следующее значение, которое распечатать! затем распечатывает макрос.

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

фносновной() {
для число в1..=10 {
если число % 2 == 0 {
продолжать; // пропустить четные числа
 }
распечатать!("{}", число); // печатаем нечетные числа
 }
}

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

Кроме того, вы можете выйти из цикла for с помощью перерыв ключевое слово. Цикл завершается при встрече с перерыв ключевое слово.

фносновной() {
для число в1..=10 {
если число == 5 {
перерыв; // выходим из цикла, когда число равно 5
 }
распечатать!("{}", число); // печатаем числа от 1 до 4
 }
}

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

Используйте управляющие структуры Rust с типами данных, чтобы освоить язык

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

Rust также предоставляет структуры. Структуры — это структуры данных, которые группируют связанные значения в один объект. Они похожи на классы в объектно-ориентированных языках, и вы даже можете определять для них методы.