Rozsdamentesítő szerkezetek és használatuk

A vezérlőstruktúrák olyan programozási konstrukciók, amelyek lehetővé teszik a programok végrehajtásának vezérlését. A vezérlőstruktúrák lehetővé teszik, hogy csak bizonyos feltételek teljesülése esetén futtasson utasításokat.

A Rust vezérlőstruktúrái kulcsfontosságúak a programfolyamat kezelésében, lehetővé téve a hatékony kódvégrehajtást, miközben az összetett feladatokat kisebb, újrafelhasználható összetevőkre egyszerűsítik.

Rozsda feltételes nyilatkozatok

A feltételes utasítások olyan konstrukciók, amelyek lehetővé teszik a kód futtatását feltételek alapján. A feltételes utasítások hasznosak a döntéshozatalhoz, mivel a program végrehajtása attól függ, hogy a feltétel kiértékelődik-e igaz vagy hamis. A rozsda biztosítja ha, más, és mérkőzés nyilatkozatok a döntéshozatalhoz.

A Rust programokban a ha Az utasítás azt vizsgálja, hogy egy bizonyos feltétel igaznak bizonyul-e. Ha igen, a program lefuttatja a kapcsolódó kódblokkot. Ha a feltétel értéke hamis, a program kihagyja azt a kódblokkot, és továbblép a következő utasításra, vagy futtatja a

más utasításblokk, ha van ilyen.

A mérkőzés Az utasítás egy hatékony vezérlőfolyam-konstrukció, amely lehetővé teszi a programok számára, hogy értékeket egyeztessenek egy sor mintával, és az illesztési minta alapján kódot hajtsanak végre.

Rust's if Statements

kijelented ha kijelentéseket a Rust programokban a ha kulcsszó után egy feltétel:

ha feltétel {
// végrehajtandó kód, ha a feltétel igaz
}

Íme egy példa arra, hogyan használhatja az if utasítást a Rust programokban:

fnfő-() {
hagyja x = 15;
ha x > 10 {
println!("x nagyobb, mint 10");
 }
}

A x változó 32 bites egész számot tartalmaz, és az if utasítás ellenőrzi, hogy x értéke nagyobb-e tíznél, mielőtt futtatná az azt kinyomtató kódblokkot.

Rust más nyilatkozatai

Használja a más kulcsszó egy kódblokk végrehajtásához, ha arra számít, hogy an ha állítás hamisnak értékelné.

ha feltétel {
// végrehajtandó kód, ha a feltétel igaz
} más {
// végrehajtandó kód, ha a feltétel hamis
}

Itt van egy példa, ahol x nem nagyobb 10-nél, a ha nyilatkozat értékeli hamis, és egy más kijelentés fut.

fnfő-(){
hagyja x = 5;
ha x > 10 {
println!("x nagyobb, mint 10");
 } más {
println!("x nem nagyobb 10-nél");
 }
}

Mivel x 5 és 5 nem nagyobb 10-nél, a program kihagyja a ha blokkolja és végrehajtja a más Blokk.

Rust mérkőzésének nyilatkozatai

Használja a mérkőzés kulcsszó az összetett döntéshozatalhoz, amely egy sor minta ellenőrzésére és a mintaegyezések alapján kód végrehajtására szolgál. Az egyezési nyilatkozatok hasonlóak a válts utasításokat a C#-ban, Go és C++.

Íme a Rust egyezési nyilatkozat szerkezete:

mérkőzés érték {
 minta1 => {
// végrehajtandó kód, ha az érték megegyezik a minta1-gyel
 },
 minta2 => {
// végrehajtandó kód, ha az érték megegyezik a minta2-vel
 },
// stb.
}

A következőképpen használhatja az egyezési utasításokat a programokban:

hagyja évfolyam = "B";
mérkőzés fokozat {
"A" => println!("Kiváló munka!"),
"B" => println!("Szép munka."),
'C' => println!(– Tudnál jobban is.),
 _ => println!(– Ez nem érvényes osztályzat.),
}

A fokozat változó egy karakter, és a mérkőzés Az utasítás azt ellenőrzi, hogy melyik karakter értékeli ki az osztályzati változó értékét, mielőtt végrehajtaná a kódot az => operátor után. Az aláhúzás (_) mintával olyan értékeket egyeztethet, amelyek nem egyeznek más mintákkal (az alapértelmezett mintával).

Hurok rozsdában

A hurkok egy alapvető konstrukció, amelyet ismétlődő feladatokhoz használnak, mint pl webkaparás és egyéb automatizált műveletek. A Rust különböző típusú hurkokat biztosít, beleértve míg hurkok, számára hurkok, és a hurok hurok.

Rust's while Loops

Míg a ciklusok ismételnek egy kódblokkot, amíg a megadott feltétel igaz. A feltétel megadása előtt meg kell adnia a while ciklusokat a Rust-ban a míg kulcsszó.

míg feltétel {
// végrehajtandó kód
}

A feltételnek egy logikai kifejezésnek kell lennie, amely meghatározza a ciklus folytatását. Amikor a feltétel értéke hamis, a hurok kilép.

Íme egy példa a Rust while ciklusra, amely egytől ötig számokat nyomtat.

fnfő-() {
hagyjamut i = 1;
míg én <= 5 {
println!("{}", i);
 én += 1;
 }
}

A while ciklus a fő- függvény áthalad a számokon egytől ötig, miközben növeli a én eggyel változó, amíg én változó nagyobb, mint öt, ahol a hurok véget ér.

A hurok Hurok

A hurok kulcsszó végtelen ciklust hoz létre, amíg kilépést nem ad meg a szünet kulcsszó.

hurok {
// végrehajtandó kód
ha feltétel {
szünet;
 }
}

A kód a hurok blokk addig fut, amíg a ciklus nem találkozik a szünet kulcsszó.

Íme egy példa a hurok hurkot nyomtathat egytől ötig számokat, mielőtt megadná a szünet kulcsszó a kilépéshez.

fnfő-() {
hagyjamut i = 1;
hurok {
println!("{}", i);
 én += 1;
ha én > 5 {
szünet;
 }
 }
}

A fő- függvény végrehajtja a ciklust, és a ha kijelentés növeli a én változó. A ha utasítás határozza meg a hurok lezárását, amikor a én változó meghaladja az ötöt.

Rust for Loops

A Rust-ban a for ciklusok egy tartományon vagy értékgyűjteményen keresztül iterálnak. Használja a számára kulcsszó a for ciklus elindításához, mielőtt megadná azt a tartományt vagy gyűjteményt, amelyre hatással van.

számára változó ban ben hatótávolság {
// végrehajtandó kód
}

A hatótávolság egy olyan kifejezés, amely értéksorozatra kiértékelődik, a változó pedig egy olyan változó, amely felváltva veszi fel a sorozat minden egyes értékét. A kódblokk a szekvencia minden egyes értékére egyszer lefut.

Íme egy példa egy for ciklusra, amely egytől tízig terjedő értékeket nyomtat.

fnfő-() {
számára én ban ben1..=10 {
println!("{}", i);
 }
}

A ciklus 1-től 10-ig terjedő értékek között iterál. Minden iterációnál az (i) változó a következő értéket tartalmazza, amely a println! makró, majd kinyomtatja.

Használhatja a folytatni kulcsszó a for-ciklusokban lévő értékek átugrásához. A következőképpen hagyhatja ki a páros számokat, ha egy tartományon dolgozik:

fnfő-() {
számára sz ban ben1..=10 {
ha szám % 2 == 0 {
folytatni; // páros számok kihagyása
 }
println!("{}", szám); // páratlan számok nyomtatása
 }
}

A ha utasítás a folytatni kulcsszó annak megadásához, hogy a ciklusnak ki kell hagynia a kettővel osztható számokat.

Ezenkívül a for-hurokból a gombbal léphet ki szünet kulcsszó. A hurok akkor ér véget, amikor találkozik a szünet kulcsszó.

fnfő-() {
számára sz ban ben1..=10 {
ha szám == 5 {
szünet; // kilép a ciklusból, ha a szám 5
 }
println!("{}", szám); // kinyomtatja a számokat 1-től 4-ig
 }
}

A ha utasítás megadja, hogy a ciklusnak akkor kell véget érnie, amikor a én változó egyenlő öttel.

Használja a Rust vezérlőstruktúráit adattípusokkal a nyelv elsajátításához

A Rust ezeket a rugalmas vezérlőstruktúrákat biztosítja a beépített és egyedi adattípusokon végzett műveletekhez. Ezeket a vezérlőstruktúrákat használhatja összetett és összetett adatszerkezetek, például tömbök, vektorok, struktúrák és enumok kezelésére.

A Rust struktúrákat is biztosít. A struktúrák olyan adatstruktúrák, amelyek a kapcsolódó értékeket egyetlen objektumba csoportosítják. Hasonlóak az objektumorientált nyelvek osztályaihoz, és még metódusokat is definiálhatunk rajtuk.