Minden, amit tudnia kell a Rust írásának megkezdéséhez

2015-ös megjelenése óta a Rust a fejlesztők egyik kedvenc programozási nyelveként vált népszerűvé. A Rust kiváló teljesítményt és biztonsági funkciókat kínál intuitív és tömör szintaxisával, amelyek kívánatossá teszik a nyelvet.

A Rust különféle programok készítésére alkalmas, beleértve a webalkalmazásokat, a parancssori eszközöket és a hálózati szolgáltatásokat. A Rust számos olyan funkciót tartalmaz, amelyeket egy modern programozási nyelvtől elvárhat, például a párhuzamosságot, a típuskövetkeztetést és egyebeket.

A Rust használatának megkezdése

A Rust egy többplatformos programozási nyelv, amely a legtöbb operációs rendszeren fut. A Rust használatának megkezdéséhez forduljon a hivataloshoz Rust weboldal és telepítse az operációs rendszerének megfelelő verziót.

A Rust telepítése után elkezdheti a programokat Rust-fájlokba írni az a .rs kiterjesztés. A rozsda sokoldalú és könnyen megtanulható. Egyszerűnek találja, ha rendelkezik előzetes programozási tapasztalattal.

Változók és állandók a Rustban

A rozsda nagyon kifejező, és többféle módon is deklarálhatók a változók. Használhatja a hagyja kulcsszó a változók deklarálásához.

A következőképpen deklarálhatja a változókat Rustban:

hagyja a: Húr;
hagyja b: i32;
hagyja c: () = ();

A a és b A változók egy karakterlánc és egy egész szám. A c A változó egy Rust egységtípus, amely függvények és kifejezések helyőrzőjeként működik.

Az opcionális adattípus-deklaráció után egyenlőségjellel deklarálhatja és inicializálhatja a változókat értékekkel.

fnfő-(){
hagyja kor: Húr = Húr::tól től("Öt éves");
hagyja kor = 5; // a bérbeadási kornak megfelelő: i32 = 5;
println!("{}", életkor);
}

A program kettőt deklarál kor változók nyomtatása előtt a println! makró. Az első kor változó határozza meg az adattípust, a második pedig nem.

Nem kell megadnia egy változó adattípusát, amikor deklarálja azt. A Rust fordító az érték adattípusából következtet a típusra fordításkor.

A Rust-ban konstansokat is deklarálhat a const kulcsszót a változók deklarálásához hasonló módon:

const életkor: &str = "Öt éves";

A konstansként deklarált változó értéke nem módosítható.

A Rust funkciót biztosít az egysoros és blokkos megjegyzésekhez. Használhat dupla perjelet (//) egysoros megjegyzésekhez:

fnfő-() {
// Ez egy soros megjegyzés
hagyja x = 5; // Ez a megjegyzés megmagyarázza az "x" változó célját
}

Többsoros megjegyzésekhez (megjegyzések blokkolása) használjon perjelet, majd egy csillagot (/*), és zárja be a blokkot egy csillaggal, majd egy perjellel (*/):

fnfő-() {
/*
 Ez egy több soron átívelő blokk megjegyzés.
 Gyakran használják egy nagyobb kódblokk leírására.
 */
hagyja x = 5;
}

Megjegyzéseinek tömörnek és egyértelműnek kell lenniük.

Tömbök rozsdában

A tömbök azonos adattípusú elemek rögzített méretű gyűjteményei. A Rust alapértelmezés szerint lefoglalja a tömböket a veremben.

Így deklarálhatja a tömböket Rustban:

fnfő-() {
hagyja számok = [1, 2, 3, 4, 5];
}

A számok tömb öt elemet tartalmaz. Az értéket a tömb egy helyén érheti el az indexe segítségével:

fnfő-() {
hagyja számok = [1, 2, 3, 4, 5];
hagyja x = számok[3];
println!("{}", x)
}

A fő- függvény kiírja a x változó, amely hozzáfér a tömb negyedik eleméhez.

Vektorok rozsdában

A Rust vektorokat biztosít a tömb korlátainak elfedésére. A vektorok dinamikus méretűek; szükség szerint növekedhetnek és zsugorodhatnak.

Így deklarálhatja a vektorokat Rustban:

fnfő-() {
hagyja my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
hagyja x = my_vec[3];
println!("{}", x)
}

A my_vec A vektor 32 bites egész számokból álló vektor. A x változó eléri a vektor negyedik elemét, és a fő- függvény kiírja az értéket a konzolra.

Rust feltételes nyilatkozatai

A feltételes kijelentések az egyik A Rust vezérlőszerkezetei programokban való döntéshozatalhoz. Használhatja a ha és más kulcsszavak a programjaiban hozott döntések kezeléséhez.

Itt van egy ha utasítás, amely egy karakterláncot nyomtat a konzolra két egész szám egyenlősége alapján.

fnfő-() {
hagyja a: i32 = 12;
ha a == 12 {
println!("egy egyenlő tizenkettővel");
 }
}

A fő- függvény kiírja a karakterláncot a println! makró, mivel a változó 12.

Használhatja a más kulcsszó az esetek kezelésére, amikor a ha Az állítás hamisan értékeli:

fnfő-() {
hagyja a: i32 = 12;
ha a == 123 {
println!("egy egyenlő tizenkettővel");
 } más {
println!("a nem egyenlő tizenkettővel");
 }
}

Ebben a példában a más utasítás lefut, mert a értéke nem egyenlő 123-mal.

Egyezési nyilatkozatokat deklarálhat a mérkőzés kulcsszó összetett feltételes feltételekhez:

fnfő-() {
hagyja kor: i32 = 7;
mérkőzés kor {
1 => println!("egy"),
2 => println!("kettő"),
3 => println!("három"),
 _ => println!("nulla"),
 }
}

A fő- függvény megegyezik a kor esetenként változó a mérkőzés utasítást, és végrehajtja az értéknek megfelelő kifejezést. Az aláhúzás (_) az alapértelmezett utasítás, amely akkor fut le, ha az érték megegyezik.

Hurok rozsdában

A Rust hurkokat biztosít az ismétlődő feladatokhoz. A rozsdának három fő hurktípusa van: hurok, míg, és számára hurkok.

A hurok A kulcsszó egy végtelen ciklust hoz létre, amely addig fut, amíg nem találkozik egy break kulcsszóval:

fnfő-() {
hurok {
println!("ismételten nyomtatva, amíg a break utasítás nem találkozik.");
szünet;
 }
}

A míg A ciklus akkor hasznos, ha meg akar ismételni egy kódblokkot mindaddig, amíg a feltétel igazra értékelődik:

fnfő-() {
hagyjamut szám = 0;
míg szám < 5 {
println!("A szám {}", számol);
 szám += 1;
 }
}

A számára A ciklus alkalmas elemgyűjtemény iterációjára, például egy tömbre:

fnfő-() {
hagyja számok = [1, 2, 3, 4, 5];
számára tétel ban ben numbers.iter() {
println!("A jelenlegi elem {}", tétel);
 }
}

Ez számára ciklus iterál a számok tömböt, és minden elemet kinyomtat a konzolra.

Rozsdafüggvények deklarálása és meghívása

Használja a fn kulcsszó deklarál egy Rust függvényt, majd a függvény neve, a paraméterek listája és a visszatérési típus (ha van).

A következőképpen deklarálhat függvényt paraméterekkel és visszatérési típussal:

fnadd hozzá(a: i32, b: i32) -> i32 {
Visszatérés a + b;
}

A add hozzá A függvény két 32 bites egész számot vesz fel, és egy 32 bites egész számot ad vissza, a két paraméter összegét.

Ha a kódban máshonnan szeretne függvényt hívni, egyszerűen adja meg a nevet és az argumentumokat (ha vannak):

fnfő-() {
hagyja eredmény = add(2, 3);
println!("2 + 3 = {}", eredmény);
}

A eredmény változó megtartja a meghívásának eredményét add hozzá funkció. A fő- függvény kinyomtatja az eredményt a konzolra a println! makró.

Struktúrák rozsdában

A Rust struktúrákat biztosít az egyéni adattípusok meghatározásához, amelyek a kapcsolódó értékeket csoportosítják. A struktúrák tervrajzok meghatározott tulajdonságokkal rendelkező objektumok létrehozásához.

Így deklarálhat egy struktúrát:

structSzemély {
 név: Húr,
 kor: u32,
 is_male: bool,
}

A Személy A struct három mezőt tartalmaz: egy karakterláncot, egy előjel nélküli 32 bites egészet és egy logikai értéket.

A struktúra meghatározása után létrehozhatja annak példányait a program más részeiben:

fnfő-() {
hagyja személy1 = személy {
 név: Húr::tól től("Candace Flynn"),
 kor: 16,
 is_male: hamis,
 };
}

A személy1 változó a Személy struct. Példányosításkor értékeket rendelhet a struct mezőkhöz. Egy struktúra tetszőleges számú példányát hozhatja létre.

Megvalósíthatja az OOP koncepciókat Rustban

A Rust rugalmas, és az OOP-koncepciókat beépített adatstruktúrákkal, például struktúrákkal valósíthatja meg a Rustban.

Struktúrákat fog használni az osztályok alternatívájaként. A Rust struktúrájával meghatározhat egy tervezetet a típushoz, és megvalósíthatja a különböző OOP koncepciókat a Rust által a struktúrákon biztosított funkciókkal.