Všetko, čo potrebujete vedieť, aby ste mohli začať písať Rust

Od svojho vydania v roku 2015 si Rust získal popularitu ako jeden z obľúbených programovacích jazykov vývojárov. Rust ponúka vynikajúci výkon a bezpečnostné funkcie s intuitívnou a stručnou syntaxou, vďaka ktorej je jazyk žiaduci.

Rust je vhodný na vytváranie rôznych programov vrátane webových aplikácií, nástrojov príkazového riadka a sieťových služieb. Rust obsahuje mnoho funkcií, ktoré očakávate od moderného programovacieho jazyka, ako je súbežnosť, odvodzovanie typu a ďalšie.

Začíname s hrdzou

Rust je multiplatformový programovací jazyk, ktorý beží na väčšine operačných systémov. Ak chcete začať s Rustom, zamierte k úradníkovi Webová stránka Rust a nainštalujte preferovanú verziu pre váš operačný systém.

Po nainštalovaní Rustu môžete začať písať programy do súborov Rust s a .rs rozšírenie. Hrdza je všestranná a ľahko sa učí. Zistíte, že je to jednoduché, ak máte predchádzajúce skúsenosti s programovaním.

Premenné a konštanty v hrdze

Hrdza je vysoko expresívna a existuje niekoľko spôsobov, ako deklarovať premenné. Môžete použiť nech kľúčové slovo na deklarovanie premenných.

Takto môžete deklarovať premenné v Ruste:

nech a: Reťazec;
nech b: i32;
nech c: () = ();

The a a b premenné sú reťazec a celé číslo. The c premenná je typ jednotky Rust, ktorý funguje ako zástupný symbol pre funkcie a výrazy.

Po voliteľnej deklarácii typu údajov môžete deklarovať a inicializovať premenné s hodnotami pomocou znamienka rovnosti.

fnHlavná(){
nech Vek: Reťazec = Reťazec::od("päť rokov");
nech vek = 5; // ekvivalentné veku: i32 = 5;
println!("{}", Vek);
}

Program deklaruje dve Vek premenných pred tlačou s println! makro. Prvý Vek premenná určuje typ údajov a druhá nie.

Pri deklarovaní premennej nemusíte špecifikovať typ údajov. Kompilátor Rust odvodzuje typ z dátového typu hodnoty v čase kompilácie.

Môžete tiež deklarovať konštanty v Rust pomocou konšt kľúčové slovo podobným spôsobom ako pri deklarovaní premenných:

konšt Vek: &str = "päť rokov";

Nemôžete zmeniť hodnotu premennej, ktorú deklarujete ako konštantu.

Rust poskytuje funkčnosť pre jednoriadkové a blokové komentáre. Môžete použiť dvojité lomky (//) pre jednoriadkové komentáre:

fnHlavná() {
// Toto je riadkový komentár
nech x = 5; // Tento komentár vysvetľuje účel premennej `x`
}

Pre viacriadkové komentáre (blokové komentáre) použite lomku nasledovanú hviezdičkou (/*) a zatvorte blok hviezdičkou, za ktorou nasleduje lomka (*/):

fnHlavná() {
/*
 Toto je blokový komentár, ktorý zahŕňa viacero riadkov.
 Často sa používa na opis väčšieho bloku kódu.
 */
nech x = 5;
}

Vaše komentáre by mali byť stručné a priame.

Pole v hrdze

Polia sú kolekciou prvkov rovnakého typu údajov s pevnou veľkosťou. Rust štandardne alokuje polia v zásobníku.

Tu je návod, ako môžete deklarovať polia v Ruste:

fnHlavná() {
nech čísla = [1, 2, 3, 4, 5];
}

The čísla pole obsahuje päť položiek. K hodnote môžete pristupovať na mieste v poli pomocou jeho indexu:

fnHlavná() {
nech čísla = [1, 2, 3, 4, 5];
nech x = čísla[3];
println!("{}", X)
}

The Hlavná funkcia vytlačí X premenná, ktorá pristupuje k štvrtému prvku poľa.

Vektory v hrdze

Rust poskytuje vektory na zakrytie obmedzení poľa. Veľkosť vektorov je dynamická; môžu rásť a zmenšovať sa podľa potreby.

Takto môžete deklarovať vektory v Ruste:

fnHlavná() {
nech my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
nech x = môj_vec[3];
println!("{}", X)
}

The my_vec vector je vektor 32-bitových celých čísel. The X premenná pristupuje k štvrtému prvku vektora a Hlavná funkcia vypíše hodnotu do konzoly.

Rustove podmienené vyhlásenia

Podmienené vyhlásenia sú jedným z Riadiace štruktúry hrdze pre rozhodovanie v programoch. Môžete použiť ak a inak kľúčové slová na spracovanie rozhodnutí vo vašich programoch.

Tu je ak príkaz, ktorý vypíše reťazec do konzoly na základe rovnosti dvoch celých čísel.

fnHlavná() {
nech a: i32 = 12;
ak a == 12 {
println!("a rovná sa dvanásť");
 }
}

The Hlavná funkcia vypíše reťazec s println! makro, pretože premenná sa rovná 12.

Môžete použiť inak kľúčové slovo na riešenie prípadov, keď ak vyhlásenie sa vyhodnotí ako nepravdivé:

fnHlavná() {
nech a: i32 = 12;
ak a == 123 {
println!("a rovná sa dvanásť");
 } inak {
println!("a nerovná sa dvanásť");
 }
}

V tomto príklade inak príkaz sa spustí, pretože hodnota a sa nerovná 123.

Môžete deklarovať zhodu s príkazom zápas kľúčové slovo pre zložité podmienky:

fnHlavná() {
nech Vek: i32 = 7;
zápas Vek {
1 => println!("jeden"),
2 => println!("dva"),
3 => println!("tri"),
 _ => println!("nula"),
 }
}

The Hlavná funkcia zodpovedá Vek premenné na prípady v zápas a vykoná výraz, ktorý sa zhoduje s hodnotou. Podčiarkovník (_) je predvolený príkaz, ktorý sa spustí, ak existuje zhoda s hodnotou.

Slučky v hrdze

Rust poskytuje slučky pre opakujúce sa úlohy. Hrdza má tri hlavné typy slučiek: slučka, zatiaľ čo, a pre slučky.

The slučka kľúčové slovo vytvorí nekonečnú slučku, ktorá beží, kým nenarazí na kľúčové slovo break:

fnHlavná() {
slučka {
println!("tlačia sa opakovane, kým sa nenájde príkaz break.");
prestávka;
 }
}

The zatiaľ čo slučka je užitočná, keď chcete opakovať blok kódu, pokiaľ sa podmienka vyhodnotí ako pravdivá:

fnHlavná() {
nechmut počítať = 0;
zatiaľ čo počítať < 5 {
println!("Počet je {}", počítať);
 počítať += 1;
 }
}

A pre slučka je dobrá na iteráciu nad kolekciou položiek, ako je pole:

fnHlavná() {
nech čísla = [1, 2, 3, 4, 5];
pre položka v čísla.iter() {
println!("Aktuálna položka je {}", položka);
 }
}

Toto pre slučka iteruje cez čísla pole a vytlačí každú položku do konzoly.

Vyhlásenie a volanie funkcií Rust

Použi fn kľúčové slovo na vyhlásiť funkciu Rust, za ktorým nasleduje názov funkcie, zoznam parametrov a návratový typ (ak existuje).

Tu je návod, ako môžete deklarovať funkciu s parametrami a návratovým typom:

fnpridať(a: i32, b: i32) -> i32 {
vrátiť a + b;
}

The pridať funkcia vezme dve 32-bitové celé čísla a vráti 32-bitové celé číslo, súčet dvoch parametrov.

Ak chcete volať funkciu z iného miesta v kóde, jednoducho zadajte názov a argumenty (ak existujú):

fnHlavná() {
nech výsledok = pridať(2, 3);
println!("2 + 3 = {}", výsledok);
}

The výsledok premenná obsahuje výsledok volania pridať funkciu. The Hlavná funkcia vytlačí výsledok do konzoly pomocou println! makro.

Konštrukcie v hrdze

Rust poskytuje štruktúry na definovanie vlastných dátových typov, ktoré zoskupujú súvisiace hodnoty. Štruktúry sú plány na vytváranie objektov so špecifickými vlastnosťami.

Takto môžete deklarovať štruktúru:

štrukturovaťOsoba {
 názov: Reťazec,
 Vek: u32,
 is_male: bool,
}

The Osoba struct má tri polia: reťazec, 32-bitové celé číslo bez znamienka a boolean.

Po definovaní štruktúry môžete vytvoriť jej inštancie v iných častiach vášho programu:

fnHlavná() {
nech osoba1 = Osoba {
 názov: Reťazec::od("Candace Flynn"),
 Vek: 16,
 is_male: falošný,
 };
}

The osoba1 premenná je inštanciou premennej Osoba štrukturovať. Pri vytváraní inštancií môžete priradiť hodnoty k poliam struct. Môžete vytvoriť toľko inštancií štruktúry, koľko chcete.

Môžete implementovať koncepty OOP v Rust

Rust je flexibilný a koncepty OOP môžete implementovať v Ruste pomocou vstavaných dátových štruktúr, ako sú štruktúry.

Štruktúry použijete ako alternatívu tried. Pomocou Rust's struct môžete definovať plán pre typ a implementovať rôzne koncepty OOP s funkciami, ktoré Rust poskytuje na štruktúrach.