Structuri de control al ruginii și cum să le folosiți

Structurile de control sunt o construcție de programare care vă permite să controlați fluxul de execuție în programele dvs. Structurile de control vă permit să specificați instrucțiuni de rulat numai dacă sunt îndeplinite anumite condiții.

Structurile de control ale Rust sunt cruciale pentru gestionarea fluxului de programe, permițând execuția eficientă a codului, simplificând în același timp sarcinile complexe în componente mai mici, reutilizabile.

Declarații condiționale Rust

Instrucțiunile condiționate sunt constructe care vă permit să rulați cod pe baza condițiilor. Declarațiile condiționale sunt utile pentru luarea deciziilor, deoarece execuția programului depinde dacă condiția se evaluează la Adevărat sau fals. Rugina oferă dacă, altfel, și Meci declarații pentru luarea deciziilor.

În programele Rust, dacă declarația testează dacă o anumită condiție este evaluată ca adevărată. Dacă o face, programul rulează blocul de cod asociat. Dacă condiția este falsă, programul omite acel bloc de cod și trece la următoarea instrucțiune sau rulează

altfel bloc de declarații dacă există.

The Meci declarația este o construcție puternică a fluxului de control care permite unui program să potrivească valori cu o serie de modele și să execute cod pe baza modelului de potrivire.

Declarații Rust’s if

vei declara dacă declarațiile din programele dvs. Rust cu dacă cuvânt cheie urmat de o condiție:

dacă condiție {
// cod de executat dacă condiția este adevărată
}

Iată un exemplu despre cum puteți utiliza o declarație if în programele dvs. Rust:

fnprincipal() {
lăsa x = 15;
dacă x > 10 {
println!(„x este mai mare decât 10”);
 }
}

The X variabila deține un număr întreg de 32 de biți, iar instrucțiunea if verifică dacă valoarea lui x este mai mare de zece înainte de a rula blocul de cod care îl tipărește.

Declarațiile celorlalte ale lui Rust

Veți folosi altfel cuvânt cheie pentru a executa un bloc de cod atunci când anticipați că an dacă afirmația ar fi evaluată ca fiind falsă.

dacă condiție {
// cod de executat dacă condiția este adevărată
} altfel {
// cod de executat dacă condiția este falsă
}

Iată un exemplu unde X nu este mai mare de 10, dacă declarația evaluează fals, si un altfel declarația rulează.

fnprincipal(){
lăsa x = 5;
dacă x > 10 {
println!(„x este mai mare decât 10”);
 } altfel {
println!(„x nu este mai mare de 10”);
 }
}

De cand X este 5 și 5 nu este mai mare de 10, programul omite dacă blochează și execută altfel bloc.

Declarațiile meciului lui Rust

Veți folosi Meci cuvânt cheie pentru luarea deciziilor complexe pentru a verifica o serie de modele și a executa codul bazat pe potriviri de modele. Declarațiile de potrivire sunt similare cu instrucțiuni switch în C#, Go și C++.

Iată structura unei declarații de potrivire Rust:

Meci valoare {
 model1 => {
// cod de executat dacă valoarea se potrivește cu pattern1
 },
 model2 => {
// cod de executat dacă valoarea se potrivește cu pattern2
 },
// etc.
}

Iată cum puteți utiliza declarațiile de potrivire în programele dvs.:

lăsa nota = „B”;
Meci nota {
'A' => println!(„Excelent lucru!”),
„B” => println!("Loc de muncă bun."),
„C” => println!(— Ai putea face mai bine.),
 _ => println!(— Asta nu este o notă valabilă.),
}

The nota variabila este un caracter, iar Meci instrucțiunea verifică pentru care dintre caractere evaluează valoarea variabilei de calificare înainte de a executa codul după operatorul =>. Puteți folosi modelul de subliniere (_) pentru a potrivi valorile care nu se potrivesc cu alte modele (modelul implicit).

Bucle în Rust

Buclele sunt un construct fundamental folosit pentru sarcini repetitive precum răzuire web și alte acțiuni automate. Rust oferă diferite tipuri de bucle, inclusiv in timp ce bucle, pentru bucle, iar buclă buclă.

Rust’s while Loops

Buclele while repetă un bloc de cod atâta timp cât o condiție specificată este adevărată. Înainte de a specifica condiția, veți specifica buclele while în Rust cu in timp ce cuvânt cheie.

in timp ce condiție {
// cod de executat
}

Condiția ar trebui să fie o expresie booleană care determină continuarea buclei. Când condiția este evaluată falsă, bucla se iese.

Iată un exemplu de buclă Rust while care imprimă numere de la unu la cinci.

fnprincipal() {
lăsamut i = 1;
in timp ce eu <= 5 {
println!("{}", i);
 i += 1;
 }
}

Bucla while din principal funcția parcurge numerele de la unu la cinci în timp ce incrementează i variabilă cu unu până la i variabila este mai mare de cinci, unde bucla se termină.

Bucla Bucla

The buclă cuvântul cheie creează o buclă infinită până când declarați o ieșire cu pauză cuvânt cheie.

buclă {
// cod de executat
dacă condiție {
pauză;
 }
}

Codul din buclă blocul va continua să se execute până când bucla întâlnește a pauză cuvânt cheie.

Iată un exemplu de utilizare a buclă bucla pentru a imprima numerele de la unu la cinci înainte de a specifica pauză cuvânt cheie pentru ieșire.

fnprincipal() {
lăsamut i = 1;
buclă {
println!("{}", i);
 i += 1;
dacă eu > 5 {
pauză;
 }
 }
}

The principal funcția execută bucla și dacă declarația crește i variabil. The dacă instrucțiunea specifică terminarea buclei atunci când i variabila depășește cinci.

Rust’s for Loops

În Rust, buclele for iterează printr-un interval sau o colecție de valori. Veți folosi pentru cuvânt cheie pentru a începe o buclă for, înainte de a specifica intervalul sau colecția pe care acționează.

pentru variabil în gamă {
// cod de executat
}

The gamă este o expresie care evaluează la o secvență de valori, iar variabila este o variabilă care preia pe rând fiecare valoare din secvență. Blocul de cod se va executa o dată pentru fiecare valoare din secvență.

Iată un exemplu de buclă for care imprimă valori cuprinse între unu și zece.

fnprincipal() {
pentru i în1..=10 {
println!("{}", i);
 }
}

Bucla iterează prin valorile de la 1 la 10. La fiecare iterație, variabila (i) deține următoarea valoare, care println! macro apoi se imprimă.

Puteți folosi continua cuvânt cheie pentru a omite valorile în bucle for. Iată cum puteți sări peste numerele pare atunci când lucrați pe un interval:

fnprincipal() {
pentru num în1..=10 {
dacă num % 2 == 0 {
continua; // sări peste numerele pare
 }
println!("{}", num); // imprimă numere impare
 }
}

The dacă declarația folosește continua cuvânt cheie pentru a specifica faptul că bucla trebuie să omite numerele divizibile cu doi.

În plus, puteți ieși dintr-o buclă for cu pauză cuvânt cheie. Bucla se termină la întâlnirea cu pauză cuvânt cheie.

fnprincipal() {
pentru num în1..=10 {
dacă num == 5 {
pauză; // ieși din buclă când numărul este egal cu 5
 }
println!("{}", num); // imprimă numerele de la 1 la 4
 }
}

The dacă instrucțiunea specifică că bucla ar trebui să se termine atunci când i variabila este egală cu cinci.

Utilizați structurile de control ale lui Rust cu tipuri de date pentru a stăpâni limba

Rust oferă aceste structuri de control flexibile pentru operațiuni pe tipuri de date încorporate și personalizate. Puteți utiliza aceste structuri de control pentru a opera pe structuri de date compuse și compuse, cum ar fi matrice, vectori, structuri și enumerari.

Rust oferă, de asemenea, structuri. Structurile sunt structuri de date care grupează valorile asociate într-un singur obiect. Sunt similare cu clasele din limbaje orientate pe obiecte și puteți chiar defini metode pe ele.