Rust je močan jezik, a kje začeti? Če ste vajeni drugega jezika, boste želeli vedeti, kako Rust obravnava te znane koncepte.
Od izdaje leta 2015 je Rust postal priljubljen kot eden najljubših programskih jezikov razvijalcev. Rust ponuja odlične zmogljivosti in varnostne funkcije z intuitivno in jedrnato sintakso, zaradi katere je jezik zaželen.
Rust je primeren za izdelavo različnih programov, vključno s spletnimi aplikacijami, orodji ukazne vrstice in omrežnimi storitvami. Rust vključuje številne funkcije, ki jih pričakujete od sodobnega programskega jezika, kot so sočasnost, sklepanje o vrsti in drugo.
Kako začeti z Rust
Rust je programski jezik za več platform, ki deluje na večini operacijskih sistemov. Če želite začeti z Rustom, se obrnite na uradnika Spletno mesto Rust in namestite želeno različico za vaš operacijski sistem.
Ko namestite Rust, lahko začnete pisati programe v datoteke Rust z a .rs razširitev. Rust je vsestranski in enostaven za učenje. To vam bo enostavno, če imate predhodne izkušnje s programiranjem.
Spremenljivke in konstante v Rustu
Rust je zelo izrazit in obstaja več načinov za deklaracijo spremenljivk. Lahko uporabite pustiti ključna beseda za deklaracijo spremenljivk.
Tukaj je opisano, kako lahko deklarirate spremenljivke v Rustu:
pustiti a: Vrvica;
pustiti b: i32;
pustiti c: () = ();
The a in b spremenljivki sta niz in celo število. The c spremenljivka je vrsta enote Rust, ki deluje kot ograda za funkcije in izraze.
Po izbirni deklaraciji podatkovnega tipa lahko deklarirate in inicializirate spremenljivke z vrednostmi z enakim znakom.
fnglavni(){
pustiti starost: Vrvica = Vrvica::od("pet let");
pustiti starost = 5; // enakovredno let age: i32 = 5;
println!("{}", starost);
}
Program razglasi dva starost spremenljivke pred tiskanjem z println! makro. Prvi starost spremenljivka določa vrsto podatkov, druga pa ne.
Ko deklarirate spremenljivko, vam ni treba podati podatkovnega tipa. Prevajalnik Rust sklepa na vrsto iz podatkovnega tipa vrednosti v času prevajanja.
V Rustu lahko deklarirate tudi konstante z konst ključno besedo na podoben način kot deklariranje spremenljivk:
konst starost: &str = "pet let";
Ne morete spremeniti vrednosti spremenljivke, ki jo deklarirate kot konstanto.
Rust zagotavlja funkcionalnost enovrstičnih in blokovnih komentarjev. Uporabite lahko dvojne poševnice (//) za enovrstične komentarje:
fnglavni() {
// To je vrstični komentar
pustiti x = 5; // Ta komentar pojasnjuje namen spremenljivke `x`
}
Za večvrstične komentarje (blok komentarje) uporabite poševnico naprej, ki ji sledi zvezdica (/*) in zaprite blok z zvezdico, ki ji sledi poševnica (*/):
fnglavni() {
/*
To je komentar bloka, ki obsega več vrstic.
Pogosto se uporablja za opis večjega bloka kode.
*/
pustiti x = 5;
}
Vaši komentarji morajo biti jedrnati in jasni.
Nizi v Rustu
Nizi so zbirka elementov iste podatkovne vrste s fiksno velikostjo. Rust privzeto dodeli nize v skladu.
Tukaj je opisano, kako lahko deklarirate nize v Rustu:
fnglavni() {
pustiti številke = [1, 2, 3, 4, 5];
}
The številke niz vsebuje pet elementov. Do vrednosti lahko dostopate na lokaciji v matriki z uporabo njenega indeksa:
fnglavni() {
pustiti številke = [1, 2, 3, 4, 5];
pustiti x = številke [3];
println!("{}", x)
}
The glavni funkcija natisne x spremenljivka, ki dostopa do četrtega elementa matrike.
Vektorji v Rustu
Rust zagotavlja vektorje za prikrivanje omejitev niza. Vektorji imajo dinamično velikost; po potrebi lahko rastejo in se krčijo.
Tukaj je opisano, kako lahko deklarirate vektorje v Rustu:
fnglavni() {
pustiti moj_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
pustiti x = moj_vec[3];
println!("{}", x)
}
The moj_vec vektor je vektor 32-bitnih celih števil. The x spremenljivka dostopa do četrtega elementa vektorja in glavni funkcija natisne vrednost na konzolo.
Rustove pogojne izjave
Pogojni stavki so eden od Rustove nadzorne strukture za odločanje v programih. Lahko uporabite če in drugače ključne besede za upravljanje odločitev v vaših programih.
Tukaj je če stavek, ki natisne niz na konzolo na podlagi enakosti dveh celih števil.
fnglavni() {
pustiti a: i32 = 12;
če a == 12 {
println!("a je enako dvanajst");
}
}
The glavni funkcija natisne niz z println! makro, ker je spremenljivka enaka 12.
Lahko uporabite drugače ključna beseda za obravnavo primerov, kjer je če izjava ovrednoti napačno:
fnglavni() {
pustiti a: i32 = 12;
če a == 123 {
println!("a je enako dvanajst");
} drugače {
println!("a ni enako dvanajst");
}
}
V tem primeru je drugače stavek se izvaja, ker vrednost a ni enaka 123.
Stavke o ujemanju lahko razglasite z tekma ključna beseda za kompleksne pogojnike:
fnglavni() {
pustiti starost: i32 = 7;
tekma starost {
1 => println!("ena"),
2 => println!("dva"),
3 => println!("tri"),
_ => println!("nič"),
}
}
The glavni funkcija se ujema z starost spremenljivka za primere v tekma stavek in izvede izraz, ki se ujema z vrednostjo. Podčrtaj (_) je privzeti stavek, ki se izvede, če se vrednost ujema.
Zanke v Rustu
Rust ponuja zanke za ponavljajoče se naloge. Rust ima tri glavne vrste zank: zanka, medtem, in za zanke.
The zanka ključna beseda ustvari neskončno zanko, ki teče, dokler ne naleti na ključno besedo break:
fnglavni() {
zanka {
println!("natisnjeno večkrat, dokler ne naletimo na prekinitveni stavek.");
odmor;
}
}
The medtem zanka je priročna, ko želite ponavljati blok kode, dokler je pogoj ocenjen kot resničen:
fnglavni() {
pustitimut štetje = 0;
medtem štetje < 5 {
println!("Število je {}", štetje);
štetje += 1;
}
}
A za zanka je dobra za ponavljanje po zbirki elementov, kot je niz:
fnglavni() {
pustiti številke = [1, 2, 3, 4, 5];
za postavka v numbers.iter() {
println!("Trenutni element je {}", postavka);
}
}
to za zanka se ponavlja skozi številke polje in natisne vsak element na konzolo.
Deklariranje in klicanje funkcij Rust
Uporabi fn ključna beseda za deklariraj funkcijo Rust, ki mu sledijo ime funkcije, seznam parametrov in vrnjena vrsta (če obstaja).
Evo, kako lahko deklarirate funkcijo s parametri in vrnjeno vrsto:
fndodati(a: i32, b: i32) -> i32 {
vrnitev a + b;
}
The dodati funkcija sprejme dve 32-bitni celi števili in vrne 32-bitno celo število, vsoto obeh parametrov.
Če želite poklicati funkcijo od drugod v vaši kodi, preprosto navedite ime in argumente (če obstajajo):
fnglavni() {
pustiti rezultat = dodaj(2, 3);
println!("2 + 3 = {}", rezultat);
}
The rezultat spremenljivka vsebuje rezultat klica dodati funkcijo. The glavni funkcija natisne rezultat na konzolo z uporabo println! makro.
Strukture v Rustu
Rust ponuja strukture za definiranje tipov podatkov po meri, ki združujejo povezane vrednosti. Strukture so načrti za ustvarjanje predmetov z določenimi lastnostmi.
Tukaj je opisano, kako lahko deklarirate strukturo:
structOseba {
ime: Vrvica,
starost: u32,
je_moški: bool,
}
The Oseba struct ima tri polja: niz, 32-bitno celo število brez predznaka in logično vrednost.
Ko definirate strukturo, lahko ustvarite njene primerke v drugih delih programa:
fnglavni() {
pustiti oseba1 = oseba {
ime: Vrvica::od("Candace Flynn"),
starost: 16,
je_moški: lažno,
};
}
The oseba1 spremenljivka je primerek Oseba struct. Pri instanciranju lahko dodelite vrednosti strukturnim poljem. Ustvarite lahko poljubno število primerkov strukture.
Koncepte OOP lahko implementirate v Rust
Rust je prilagodljiv in lahko implementirate OOP koncepte v Rust z vgrajenimi podatkovnimi strukturami, kot so strukture.
Strukture boste uporabljali kot alternativo razredom. Z Rustovo strukturo lahko definirate načrt za vrsto in implementirate različne OOP koncepte s funkcionalnostmi, ki jih Rust ponuja na strukturah.