Alles wat u moet weten om te beginnen met het schrijven van Rust

Sinds de release in 2015 is Rust populair geworden als een van de favoriete programmeertalen van ontwikkelaars. Rust biedt uitstekende prestaties en beveiligingsfuncties met intuïtieve en beknopte syntaxis die de taal aantrekkelijk maken.

Rust is geschikt voor het bouwen van verschillende programma's, waaronder web-apps, opdrachtregelprogramma's en netwerkservices. Rust bevat veel functies die u van een moderne programmeertaal mag verwachten, zoals gelijktijdigheid, type-inferentie en meer.

Aan de slag met roest

Rust is een platformonafhankelijke programmeertaal die op de meeste besturingssystemen draait. Om met Rust aan de slag te gaan, ga je naar de official Rust-website en installeer de voorkeursversie voor uw besturingssysteem.

Nadat u Rust hebt geïnstalleerd, kunt u beginnen met het schrijven van programma's in Rust-bestanden met een .rs verlenging. Roest is veelzijdig en gemakkelijk te leren. Je zult het eenvoudig vinden als je eerdere programmeerervaring hebt.

Variabelen en constanten in roest

Rust is zeer expressief en er zijn meerdere manieren om variabelen te declareren. U kunt de laten trefwoord om variabelen te declareren.

Hier leest u hoe u variabelen in Rust kunt declareren:

laten A: Snaar;
laten B: i32;
laten c: () = ();

De A En B variabelen zijn respectievelijk een tekenreeks en een geheel getal. De C variabele is een Rust-eenheidstype dat fungeert als tijdelijke aanduiding voor functies en uitdrukkingen.

Na de optionele declaratie van het gegevenstype kunt u variabelen declareren en initialiseren met waarden die een gelijkteken gebruiken.

fnvoornaamst(){
laten leeftijd: Snaar = Snaar::van("vijf jaar oud");
laten leeftijd = 5; // equivalent aan leeftijd: i32 = 5;
println!("{}", leeftijd);
}

Het programma declareert er twee leeftijd variabelen voordat u afdrukt met de println! macro. De eerste leeftijd variabele specificeert het gegevenstype, en de tweede niet.

U hoeft het gegevenstype van een variabele niet op te geven wanneer u deze declareert. De Rust-compiler leidt het type af van het gegevenstype van de waarde tijdens het compileren.

Je kunt ook constanten declareren in Rust met de const trefwoord op een vergelijkbare manier als het declareren van variabelen:

const leeftijd: &str = "vijf jaar oud";

U kunt de waarde van een variabele die u declareert als een constante niet wijzigen.

Rust biedt functionaliteit voor enkelregelige en blokopmerkingen. U kunt dubbele schuine strepen (//) voor opmerkingen van één regel:

fnvoornaamst() {
// Dit is een regelcommentaar
laten x= 5; // Deze opmerking legt het doel van de variabele `x` uit
}

Gebruik voor opmerkingen over meerdere regels (blokcommentaar) een schuine streep gevolgd door een asterisk (/*) en sluit het blok af met een asterisk gevolgd door een schuine streep (*/):

fnvoornaamst() {
/*
 Dit is een blokopmerking die meerdere regels omvat.
 Het wordt vaak gebruikt om een ​​groter codeblok te beschrijven.
 */
laten x= 5;
}

Uw opmerkingen moeten beknopt en duidelijk zijn.

Arrays in roest

Arrays zijn een verzameling elementen met een vaste grootte van hetzelfde gegevenstype. Rust wijst standaard arrays op de stapel toe.

Hier leest u hoe u arrays in Rust kunt declareren:

fnvoornaamst() {
laten nummers = [1, 2, 3, 4, 5];
}

De nummers array bevat vijf items. U hebt toegang tot de waarde op een locatie in een array met behulp van de index:

fnvoornaamst() {
laten nummers = [1, 2, 3, 4, 5];
laten x = getallen[3];
println!("{}", X)
}

De voornaamst functie drukt de X variabele die toegang heeft tot het vierde element van de array.

Vectoren in roest

Rust levert vectoren om de beperkingen van de array te verdoezelen. Vectoren hebben een dynamische grootte; ze kunnen naar behoefte groeien en krimpen.

Zo kun je vectoren declareren in Rust:

fnvoornaamst() {
laten mijn_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
laten x = mijn_vec[3];
println!("{}", X)
}

De mijn_vec vector is een vector van 32-bits gehele getallen. De X variabele geeft toegang tot het vierde element van de vector, en de voornaamst functie drukt de waarde af naar de console.

De voorwaardelijke verklaringen van Rust

Voorwaardelijke verklaringen zijn er een van De controlestructuren van Rust voor besluitvorming in programma's. U kunt de als En anders trefwoorden om beslissingen in uw programma's af te handelen.

Hier is een als instructie die een tekenreeks naar de console afdrukt op basis van de gelijkheid van twee gehele getallen.

fnvoornaamst() {
laten A: i32 = 12;
als een == 12 {
println!("a is gelijk aan twaalf");
 }
}

De voornaamst functie drukt de string af met de println! macro aangezien de variabele gelijk is aan 12.

U kunt de anders trefwoord om gevallen te behandelen waarin de als verklaring evalueert onwaar:

fnvoornaamst() {
laten A: i32 = 12;
als een == 123 {
println!("a is gelijk aan twaalf");
 } anders {
println!("a is niet gelijk aan twaalf");
 }
}

In dit voorbeeld is de anders instructie wordt uitgevoerd omdat de waarde van a niet gelijk is aan 123.

U kunt matchverklaringen declareren met de overeenkomst trefwoord voor complexe voorwaarden:

fnvoornaamst() {
laten leeftijd: i32 = 7;
overeenkomst leeftijd {
1 => println!("een"),
2 => println!("twee"),
3 => println!("drie"),
 _ => println!("nul"),
 }
}

De voornaamst functie past bij de leeftijd variabel naar gevallen in de overeenkomst statement en voert de expressie uit die overeenkomt met de waarde. Het onderstrepingsteken (_) is de standaardinstructie die wordt uitgevoerd als er een overeenkomst is met de waarde.

Lussen in Roest

Rust biedt lussen voor repetitieve taken. Rust heeft drie hoofdtypen lussen: lus, terwijl, En voor lussen.

De lus keyword creëert een oneindige lus die loopt totdat het een break-trefwoord tegenkomt:

fnvoornaamst() {
lus {
println!("herhaaldelijk afgedrukt totdat de break-instructie wordt aangetroffen.");
pauze;
 }
}

De terwijl lus is handig wanneer u een codeblok wilt herhalen zolang een voorwaarde als waar wordt geëvalueerd:

fnvoornaamst() {
latenmuts tel = 0;
terwijl tel < 5 {
println!("Het aantal is {}", graaf);
 tel += 1;
 }
}

A voor loop is goed voor het herhalen van een verzameling items, zoals een array:

fnvoornaamst() {
laten nummers = [1, 2, 3, 4, 5];
voor item in nummers.iter() {
println!("Het huidige item is {}", punt);
 }
}

Dit voor lus itereert door de nummers array en drukt elk item af naar de console.

Roestfuncties declareren en aanroepen

Gebruik de fn trefwoord aan declareer een Rust-functie, gevolgd door de functienaam, een lijst met parameters en een retourtype (indien aanwezig).

Hier ziet u hoe u een functie kunt declareren met parameters en een retourtype:

fntoevoegen(A: i32, B: i32) -> i32 {
opbrengst een + b;
}

De toevoegen functie neemt twee 32-bits gehele getallen op en retourneert een 32-bits geheel getal, de som van de twee parameters.

Om een ​​functie van elders in uw code aan te roepen, hoeft u alleen maar de naam en argumenten (indien aanwezig) op te geven:

fnvoornaamst() {
laten resultaat = toevoegen(2, 3);
println!("2 + 3 = {}", resultaat);
}

De resultaat variabele bevat het resultaat van het aanroepen van de toevoegen functie. De voornaamst functie drukt het resultaat af naar de console met behulp van de println! macro.

Constructies in roest

Rust biedt structs voor het definiëren van aangepaste gegevenstypen die gerelateerde waarden groeperen. Structuren zijn blauwdrukken voor het maken van objecten met specifieke eigenschappen.

Zo kun je een struct declareren:

structuurPersoon {
 naam: Snaar,
 leeftijd: u32,
 is_mannelijk: boel,
}

De Persoon struct heeft drie velden: een tekenreeks, een niet-ondertekend 32-bits geheel getal en een booleaanse waarde.

Nadat je een struct hebt gedefinieerd, kun je er instanties van maken in andere delen van je programma:

fnvoornaamst() {
laten persoon1 = Persoon {
 naam: Snaar::van("Candace Flynn"),
 leeftijd: 16,
 is_mannelijk: vals,
 };
}

De persoon1 variabele is een instantie van de Persoon structuur. Bij instantiëring kunt u waarden toewijzen aan de struct-velden. U kunt zoveel instanties van een structuur maken als u wilt.

U kunt OOP-concepten in Rust implementeren

Rust is flexibel en u kunt de OOP-concepten in Rust implementeren met ingebouwde datastructuren zoals structs.

Je gebruikt structs als alternatief voor klassen. Met Rust's struct kun je een blauwdruk voor het type definiëren en de verschillende OOP-concepten implementeren met de functionaliteiten die Rust op structs biedt.