Структуре за контролу рђе и како их користити

Контролне структуре су програмска конструкција која вам омогућава да контролишете ток извршења у вашим програмима. Контролне структуре вам омогућавају да одредите упутства која ће се изводити само ако су испуњени одређени услови.

Руст-ове контролне структуре су кључне за управљање током програма, омогућавајући ефикасно извршавање кода док поједностављују сложене задатке у мање компоненте које се могу поново користити.

Руст условне изјаве

Условне изјаве су конструкције које вам омогућавају да покренете код на основу услова. Условне изјаве су корисне за доношење одлука јер извршење програма зависи од тога да ли се услов процењује на истина или лажно. Руст пружа ако, друго, и меч изјаве за доношење одлука.

У Руст програмима, ако изјава тестира да ли је одређени услов тачан. Ако јесте, програм покреће придружени блок кода. Ако је услов нетачан, програм прескаче тај блок кода и прелази на следећу наредбу или покреће друго блок изјава ако га има.

Тхе меч наредба је моћна конструкција тока контроле која омогућава програму да упореди вредности са низом образаца и изврши код на основу обрасца подударања.

Руст’с иф изјаве

Изјаснићете се ако изјаве у вашим Руст програмима са ако кључна реч праћена условом:

ако стање {
// код за извршење ако је услов истинит
}

Ево примера како можете да користите иф наредбу у својим Руст програмима:

фнглавни() {
дозволити к = 15;
ако к > 10 {
принтлн!(„к је веће од 10“);
 }
}

Тхе Икс променљива садржи 32-битни цео број, а иф изјава проверава да ли је вредност к већа од десет пре него што покрене блок кода који га штампа.

Рустове друге изјаве

Користићете друго кључну реч за извршавање блока кода када очекујете да ће ан ако изјава би се оценила као лажна.

ако стање {
// код за извршење ако је услов истинит
} друго {
// код за извршење ако је услов нетачан
}

Ево примера где Икс није већи од 10, ако исказ оцењује лажно, и један друго изјава ради.

фнглавни(){
дозволити к = 5;
ако к > 10 {
принтлн!(„к је веће од 10“);
 } друго {
принтлн!("к није веће од 10");
 }
}

Од Икс је 5 и 5 није веће од 10, програм прескаче ако блокира и извршава друго блокирати.

Рустове изјаве о подударању

Користићете меч кључна реч за сложено доношење одлука за проверу низа образаца и извршавање кода на основу подударања шаблона. Изјаве о утакмици су сличне свитцх наредбе у Ц#, Го и Ц++.

Ево структуре Руст изјаве:

меч вредност {
 образац1 => {
// код за извршење ако се вредност поклапа са шаблоном1
 },
 образац2 => {
// код за извршавање ако се вредност поклапа са шаблоном2
 },
// итд.
}

Ево како можете да користите исказе подударања у својим програмима:

дозволити оцена = 'Б';
меч оцена {
'А' => принтлн!("Одлицан посао!"),
'Б' => принтлн!("Добар посао."),
'Ц' => принтлн!("Могао би и боље."),
 _ => принтлн!(„То није ваљана оцена.“),
}

Тхе разред променљива је знак, а меч наредба проверава који од знакова вреднује вредност променљиве оцене пре извршавања кода после оператора =>. Можете да користите образац доње црте (_) да бисте ускладили вредности које се не подударају са другим обрасцима (подразумевани образац).

Лоопс ин Руст

Петље су основна конструкција која се користи за задатке који се понављају као што је веб стругање и друге аутоматизоване радње. Руст пружа различите врсте петљи, укључујући док петље, за петље, и петља петља.

Руст’с вхиле Лоопс

Док петље понављају блок кода све док одређени услов процењује тачно. Пре него што наведете услов, одредићете вхиле петље у Русту са док кључна реч.

док стање {
// код за извршење
}

Услов треба да буде логички израз који одређује наставак петље. Када се услов оцени као нетачан, петља излази.

Ево примера Руст вхиле петље која штампа бројеве од један до пет.

фнглавни() {
дозволитимут и = 1;
док и <= 5 {
принтлн!("{}", и);
 и += 1;
 }
}

Док петља у главни функција пролази кроз бројеве од један до пет док повећава и променљива за један док и променљива је већа од пет, где се петља завршава.

Петља Лооп

Тхе петља кључна реч ствара бесконачну петљу док не наведете излаз са пауза кључна реч.

петља {
// код за извршење
ако стање {
пауза;
 }
}

Код у петља блок ће наставити да се извршава све док петља не наиђе на а пауза кључна реч.

Ево примера коришћења петља петља за штампање бројева од један до пет пре него што наведете пауза кључна реч за излаз.

фнглавни() {
дозволитимут и = 1;
петља {
принтлн!("{}", и);
 и += 1;
ако и > 5 {
пауза;
 }
 }
}

Тхе главни функција извршава петљу, а ако изјава повећава и променљива. Тхе ако израз специфицира завршетак петље када је и варијабла прелази пет.

Руст’с фор Лоопс

У Русту, фор петље се понављају кроз опсег или колекцију вредности. Користићете за кључну реч за покретање фор петље, пре него што наведете опсег или колекцију на коју делује.

за променљива ин домет {
// код за извршење
}

Тхе домет је израз који вреднује низ вредности, а променљива је променљива која заузврат преузима сваку вредност у низу. Блок кода ће се извршити једном за сваку вредност у низу.

Ево примера фор петље која штампа вредности у распону од један до десет.

фнглавни() {
за и ин1..=10 {
принтлн!("{}", и);
 }
}

Петља се понавља кроз вредности од 1 до 10. На свакој итерацији, променљива (и) има следећу вредност, тј принтлн! макро се затим штампа.

Можете користити Настави кључна реч за прескакање вредности у фор-петљама. Ево како можете да прескочите парне бројеве када радите на опсегу:

фнглавни() {
за бр ин1..=10 {
ако број % 2 == 0 {
Настави; // прескочи парне бројеве
 }
принтлн!("{}", нум); // штампа непарне бројеве
 }
}

Тхе ако изјава користи Настави кључну реч да одредите да петља треба да прескочи бројеве дељиве са два.

Поред тога, можете изаћи из фор-петље помоћу пауза кључна реч. Петља се завршава када наиђе на пауза кључна реч.

фнглавни() {
за бр ин1..=10 {
ако нум == 5 {
пауза; // излаз из петље када је број једнак 5
 }
принтлн!("{}", нум); // штампа бројеве од 1 до 4
 }
}

Тхе ако израз специфицира да петља треба да се заврши када се и променљива је једнака пет.

Користите Рустове контролне структуре са типовима података да бисте савладали језик

Руст обезбеђује ове флексибилне контролне структуре за операције над уграђеним и прилагођеним типовима података. Можете користити ове контролне структуре за рад на сложеним и композитним структурама података као што су низови, вектори, структуре и енумови.

Руст такође обезбеђује структуре. Структуре су структуре података које групишу повезане вредности у један објекат. Они су слични класама у објектно оријентисаним језицима, а на њима можете чак и дефинисати методе.