Започнете своята кариера в програмирането на Rust, като научите за тези основи на езика.

Контролните структури са програмна конструкция, която ви позволява да контролирате потока на изпълнение във вашите програми. Контролните структури ви позволяват да зададете инструкции за изпълнение само ако са изпълнени определени условия.

Контролните структури на Rust са от решаващо значение за управление на програмния поток, като позволяват ефективно изпълнение на код, като същевременно опростяват сложните задачи в по-малки, многократно използвани компоненти.

Условни инструкции за Rust

Условните изрази са конструкции, които ви позволяват да изпълнявате код въз основа на условия. Условните изрази са полезни за вземане на решения, тъй като изпълнението на програмата зависи от това дали условието се оценява на вярно или невярно. Rust предоставя ако, друго, и съвпада становища за вземане на решение.

В програмите на Rust, ако изразът тества дали определено условие се оценява като вярно. Ако го направи, програмата изпълнява свързания блок код. Ако условието е невярно, програмата пропуска този блок от код и преминава към следващия оператор или изпълнява

instagram viewer
друго блок с изявления, ако има такъв.

The съвпада операторът е мощна конструкция на контролния поток, която позволява на програмата да съпоставя стойности срещу поредица от шаблони и да изпълнява код въз основа на съвпадащия шаблон.

Rust's if Изявления

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

ако състояние {
// код за изпълнение, ако условието е вярно
}

Ето пример за това как можете да използвате оператор if във вашите програми на Rust:

fnосновен() {
позволявам x = 15;
ако x > 10 {
println!("x е по-голямо от 10");
 }
}

The х променливата съдържа 32-битово цяло число и операторът if проверява дали стойността на x е по-голяма от десет, преди да изпълни блока от код, който го отпечатва.

Други изявления на Rust

Ще използвате друго ключова дума за изпълнение на блок от код, когато очаквате, че an ако твърдението би се оценило като невярно.

ако състояние {
// код за изпълнение, ако условието е вярно
} друго {
// код за изпълнение, ако условието е невярно
}

Ето пример къде х не е по-голямо от 10, ако изявлението оценява невярно, и ан друго изявление работи.

fnосновен(){
позволявам x = 5;
ако x > 10 {
println!("x е по-голямо от 10");
 } друго {
println!("x не е по-голямо от 10");
 }
}

От х е 5 и 5 не е по-голямо от 10, програмата пропуска ако блокира и изпълнява друго блок.

Изявления за съвпадение на Rust

Ще използвате съвпада ключова дума за комплексно вземане на решения за проверка на поредица от шаблони и изпълнение на код въз основа на съвпадения на шаблони. Изявленията за съвпадение са подобни на изявления за превключване в C#, Go и C++.

Ето структурата на изявление за съответствие на Rust:

съвпада стойност {
 pattern1 => {
// код за изпълнение, ако стойността съвпада с pattern1
 },
 pattern2 => {
// код за изпълнение, ако стойността съвпада с pattern2
 },
// и т.н.
}

Ето как можете да използвате изрази за съвпадение във вашите програми:

позволявам клас = "Б";
съвпада оценка {
"А" => println!("Отлична работа!"),
"Б" => println!("Добра работа."),
'° С' => println!(— Можеш да се справиш по-добре.),
 _ => println!(„Това не е валидна оценка.“),
}

The клас променливата е символ, а съвпада операторът проверява кой от знаците се оценява на стойността на променливата за оценка, преди да изпълни кода след оператора =>. Можете да използвате шаблона за долна черта (_), за да съответствате на стойности, които не съответстват на други шаблони (моделът по подразбиране).

Примки в Rust

Циклите са основна конструкция, използвана за повтарящи се задачи като уеб скрапинг и други автоматизирани действия. Rust предоставя различни видове цикли, включително докато примки, за бримки и цикъл цикъл.

Rust’s while Loops

Докато циклите повтарят блок от код, докато дадено условие е вярно. Преди да посочите условието, ще посочите цикли while в Rust с докато ключова дума.

докато състояние {
// код за изпълнение
}

Условието трябва да бъде булев израз, който определя продължението на цикъла. Когато условието се окаже невярно, цикълът излиза.

Ето пример за цикъл на Rust while, който отпечатва числа от едно до пет.

fnосновен() {
позволяваммут аз = 1;
докато аз <= 5 {
println!("{}", i);
 аз += 1;
 }
}

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

Примката Loop

The цикъл ключовата дума създава безкраен цикъл, докато не посочите изход с прекъсвам ключова дума.

цикъл {
// код за изпълнение
ако състояние {
прекъсвам;
 }
}

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

Ето пример за използване на цикъл цикъл за отпечатване на числа от едно до пет, преди да посочите прекъсвам ключова дума за изхода.

fnосновен() {
позволяваммут аз = 1;
цикъл {
println!("{}", i);
 аз += 1;
ако аз > 5 {
прекъсвам;
 }
 }
}

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

Rust’s for Loops

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

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

The диапазон е израз, който се оценява на последователност от стойности, а променливата е променлива, която приема всяка стойност в последователността на свой ред. Кодовият блок ще се изпълни веднъж за всяка стойност в последователността.

Ето пример за for цикъл, който отпечатва стойности, вариращи от едно до десет.

fnосновен() {
за аз в1..=10 {
println!("{}", i);
 }
}

Цикълът преминава през стойностите от 1 до 10. При всяка итерация променливата (i) съдържа следващата стойност, която println! след това се отпечатва макрос.

Можете да използвате продължи ключова дума за пропускане на стойности във for-цикли. Ето как можете да пропуснете четните числа, когато работите с диапазон:

fnосновен() {
за бр в1..=10 {
ако брой % 2 == 0 {
продължи; // пропускане на четни числа
 }
println!("{}", брой); // отпечатване на нечетни числа
 }
}

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

Освен това можете да излезете от for-цикъл с прекъсвам ключова дума. Цикълът завършва при среща с прекъсвам ключова дума.

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

The ако изразът указва, че цикълът трябва да приключи, когато аз променлива е равна на пет.

Използвайте контролните структури на Rust с типове данни, за да овладеете езика

Rust предоставя тези гъвкави контролни структури за операции с вградени и персонализирани типове данни. Можете да използвате тези контролни структури, за да работите със съставни и съставни структури от данни като масиви, вектори, структури и преброявания.

Rust също предоставя структури. Структурите са структури от данни, които групират свързани стойности в един обект. Те са подобни на класове в обектно-ориентирани езици и дори можете да дефинирате методи върху тях.