Tot ce trebuie să știți pentru a începe să scrieți Rust

De la lansarea sa în 2015, Rust a câștigat popularitate ca unul dintre limbajele de programare preferate ale dezvoltatorilor. Rust oferă performanțe excelente și caracteristici de securitate cu o sintaxă intuitivă și concisă care fac limbajul dezirabil.

Rust este potrivit pentru construirea diferitelor programe, inclusiv aplicații web, instrumente de linie de comandă și servicii de rețea. Rust include multe caracteristici pe care le veți aștepta de la un limbaj de programare modern, cum ar fi concurența, inferența tipului și multe altele.

Începeți cu Rust

Rust este un limbaj de programare multiplatformă care rulează pe majoritatea sistemelor de operare. Pentru a începe cu Rust, mergeți la oficial Site-ul Rust și instalați versiunea preferată pentru sistemul dvs. de operare.

După ce ați instalat Rust, puteți începe să scrieți programe în fișierele Rust cu a

.rs extensie. Rust este versatil și ușor de învățat. Veți găsi că este simplu dacă aveți experiență anterioară în programare.

Variabile și constante în Rust

Rugina este foarte expresivă și există mai multe moduri de a declara variabile. Puteți folosi lăsa cuvânt cheie pentru a declara variabile.

Iată cum puteți declara variabile în Rust:

lăsa A: Şir;
lăsa b: i32;
lăsa c: () = ();

The A și b variabilele sunt un șir și, respectiv, un întreg. The c variabila este un tip de unitate Rust care acționează ca un substituent pentru funcții și expresii.

După declararea opțională a tipului de date, puteți declara și inițializa variabile cu valori folosind un semn egal.

fnprincipal(){
lăsa vârstă: Şir = Şir::din("cinci ani");
lăsa varsta = 5; // echivalent cu let age: i32 = 5;
println!("{}", vârsta);
}

Programul declară două vârstă variabile înainte de a imprima cu println! macro. Primul vârstă variabila specifică tipul de date, iar a doua nu.

Nu trebuie să specificați tipul de date al unei variabile atunci când o declarați. Compilatorul Rust deduce tipul din tipul de date al valorii la momentul compilării.

De asemenea, puteți declara constante în Rust cu const cuvânt cheie într-un mod similar cu declararea variabilelor:

const vârsta: &str = "cinci ani";

Nu puteți modifica valoarea unei variabile pe care o declarați ca constantă.

Rust oferă funcționalitate pentru comentarii pe o singură linie și bloc. Puteți folosi bare oblice duble (//) pentru comentarii pe un singur rând:

fnprincipal() {
// Acesta este un comentariu pe rând
lăsa x = 5; // Acest comentariu explică scopul variabilei `x`
}

Pentru comentariile pe mai multe rânduri (comentarii blocate), utilizați o bară oblică urmată de un asterisc (/*) și închideți blocul cu un asterisc urmat de o bară oblică (*/):

fnprincipal() {
/*
 Acesta este un comentariu de bloc care se întinde pe mai multe rânduri.
 Este adesea folosit pentru a descrie un bloc mai mare de cod.
 */
lăsa x = 5;
}

Comentariile dvs. ar trebui să fie concise și directe.

Arrays in Rust

Matricele sunt o colecție de dimensiuni fixe de elemente de același tip de date. Rust alocă matrice pe stivă în mod implicit.

Iată cum puteți declara matrice în Rust:

fnprincipal() {
lăsa numere = [1, 2, 3, 4, 5];
}

The numere matricea conține cinci elemente. Puteți accesa valoarea într-o locație dintr-o matrice folosind indexul acesteia:

fnprincipal() {
lăsa numere = [1, 2, 3, 4, 5];
lăsa x = numere[3];
println!("{}", X)
}

The principal funcția imprimă X variabilă care accesează al patrulea element al matricei.

Vectori în Rust

Rust oferă vectori pentru a acoperi limitările matricei. Vectorii sunt dimensionați dinamic; pot crește și micșora după nevoie.

Iată cum puteți declara vectori în Rust:

fnprincipal() {
lăsa my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
lăsa x = my_vec[3];
println!("{}", X)
}

The my_vec vector este un vector de numere întregi de 32 de biți. The X variabila accesează al patrulea element al vectorului și principal funcția imprimă valoarea pe consolă.

Declarațiile condiționale ale lui Rust

Declarațiile condiționale sunt una dintre Structurile de control ale Rust pentru luarea deciziilor în programe. Puteți folosi dacă și altfel cuvinte cheie pentru a gestiona deciziile în programele dvs.

Iată un dacă instrucțiune care imprimă un șir în consolă pe baza egalității a două numere întregi.

fnprincipal() {
lăsa A: i32 = 12;
dacă a == 12 {
println!("a este egal cu doisprezece");
 }
}

The principal funcția imprimă șirul cu println! macro deoarece variabila este egală cu 12.

Puteți folosi altfel cuvânt cheie pentru a gestiona cazurile în care dacă afirmația evaluează fals:

fnprincipal() {
lăsa A: i32 = 12;
dacă a == 123 {
println!("a este egal cu doisprezece");
 } altfel {
println!("a nu este egal cu doisprezece");
 }
}

În acest exemplu, altfel instrucțiunea rulează deoarece valoarea lui a nu este egală cu 123.

Puteți declara declarații de potrivire cu Meci cuvânt cheie pentru condiționale complexe:

fnprincipal() {
lăsa vârstă: i32 = 7;
Meci varsta {
1 => println!("unu"),
2 => println!("Două"),
3 => println!("Trei"),
 _ => println!("zero"),
 }
}

The principal funcția se potrivește cu vârstă variabilă la cazurile din Meci instrucțiune și execută expresia care se potrivește cu valoarea. Literul de subliniere (_) este instrucțiunea implicită care rulează dacă există o potrivire pentru valoare.

Bucle în Rust

Rugina oferă bucle pentru sarcini repetitive. Rust are trei tipuri principale de bucle: buclă, in timp ce, și pentru bucle.

The buclă cuvântul cheie creează o buclă infinită care rulează până când întâlnește un cuvânt cheie break:

fnprincipal() {
buclă {
println!(„Tipărit în mod repetat până când este întâlnită instrucțiunea break”.);
pauză;
 }
}

The in timp ce bucla este utilă atunci când doriți să repetați un bloc de cod atâta timp cât o condiție se evaluează la adevărat:

fnprincipal() {
lăsamut numără = 0;
in timp ce numără < 5 {
println!(„Numărul este {}”, numara);
 numără += 1;
 }
}

A pentru bucla este bună pentru iterarea peste o colecție de elemente, cum ar fi o matrice:

fnprincipal() {
lăsa numere = [1, 2, 3, 4, 5];
pentru articol în numere.iter() {
println!(„Articolul curent este {}”, articol);
 }
}

Acest pentru bucla iterează prin numere matrice și imprimă fiecare articol pe consolă.

Declararea și apelarea funcțiilor Rust

Folosește fn cuvânt cheie pentru declară o funcție Rust, urmat de numele funcției, o listă de parametri și un tip de returnare (dacă există).

Iată cum puteți declara o funcție cu parametri și un tip de returnare:

fnadăuga(A: i32, b: i32) -> i32 {
întoarcere a + b;
}

The adăuga funcția preia două numere întregi de 32 de biți și returnează un număr întreg de 32 de biți, suma celor doi parametri.

Pentru a apela o funcție din altă parte a codului dvs., specificați pur și simplu numele și argumentele (dacă există):

fnprincipal() {
lăsa rezultat = adauga(2, 3);
println!("2 + 3 = {}", rezultat);
}

The rezultat variabila deține rezultatul apelării la adăuga funcţie. The principal funcția imprimă rezultatul pe consolă folosind println! macro.

Structuri în Rust

Rust oferă structuri pentru definirea tipurilor de date personalizate care grupează valorile asociate. Structurile sunt planuri pentru crearea de obiecte cu proprietăți specifice.

Iată cum puteți declara o structură:

structPersoană {
 Nume: Şir,
 vârstă: u32,
 este_masculin: bool,
}

The Persoană struct are trei câmpuri: un șir de caractere, un număr întreg nesemnat de 32 de biți și un boolean.

După definirea unei structuri, puteți crea instanțe ale acesteia în alte părți ale programului dvs.:

fnprincipal() {
lăsa person1 = Persoana {
 Nume: Şir::din(„Candace Flynn”),
 vârstă: 16,
 este_masculin: fals,
 };
}

The persoana1 variabila este o instanță a Persoană struct. La instanțiere, puteți atribui valori câmpurilor struct. Puteți crea oricâte instanțe ale unei structuri doriți.

Puteți implementa concepte OOP în Rust

Rust este flexibil și puteți implementa conceptele POO în Rust cu structuri de date încorporate, cum ar fi structuri.

Veți folosi structuri ca alternativă la clase. Cu structura lui Rust, puteți defini un plan pentru tip și puteți implementa diferitele concepte OOP cu funcționalitățile oferite de Rust pentru structuri.