Allt du behöver veta för att börja skriva rost

Sedan lanseringen 2015 har Rust blivit populärt som ett av utvecklarnas favoritprogrammeringsspråk. Rust erbjuder utmärkt prestanda och säkerhetsfunktioner med intuitiv och koncis syntax som gör språket önskvärt.

Rust lämpar sig för att bygga olika program, inklusive webbappar, kommandoradsverktyg och nätverkstjänster. Rust innehåller många funktioner du kan förvänta dig av ett modernt programmeringsspråk, som samtidighet, typinferens och mer.

Komma igång med rost

Rust är ett plattformsoberoende programmeringsspråk som körs på de flesta operativsystem. För att komma igång med Rust, gå till tjänstemannen Rust hemsida och installera den föredragna versionen för ditt operativsystem.

När du har installerat Rust kan du börja skriva program i Rust-filer med en .rs förlängning. Rust är mångsidig och lätt att lära sig. Du kommer att tycka att det är enkelt om du har tidigare erfarenhet av programmering.

Variabler och konstanter i rost

Rost är mycket uttrycksfullt, och det finns flera sätt att deklarera variabler. Du kan använda låta nyckelord för att deklarera variabler.

Så här kan du deklarera variabler i Rust:

låta a: Sträng;
låta b: i32;
låta c: () = ();

De a och b variabler är en sträng respektive ett heltal. De c variabel är en Rustenhetstyp som fungerar som en platshållare för funktioner och uttryck.

Efter den valfria datatypsdeklarationen kan du deklarera och initiera variabler med värden med ett likhetstecken.

fnhuvud(){
låta ålder: Sträng = Sträng::från("fem år gammal");
låta ålder = 5; // motsvarar låt ålder: i32 = 5;
println!("{}", ålder);
}

Programmet förklarar två ålder variabler innan du skriver ut med println! makro. Den första ålder variabel anger datatypen, och den andra gör det inte.

Du behöver inte ange datatypen för en variabel när du deklarerar den. Rust-kompilatorn härleder typen från värdets datatyp vid kompileringstillfället.

Du kan också deklarera konstanter i Rust med konst nyckelord på liknande sätt som att deklarera variabler:

konst ålder: &str = "fem år gammal";

Du kan inte ändra värdet på en variabel som du deklarerar som en konstant.

Rust ger funktionalitet för enkelrads- och blockkommentarer. Du kan använda dubbla snedstreck (//) för kommentarer på en rad:

fnhuvud() {
// Detta är en radkommentar
låta x = 5; // Den här kommentaren förklarar syftet med variabeln "x".
}

För kommentarer med flera rader (blockkommentarer), använd ett snedstreck följt av en asterisk (/*) och stäng blocket med en asterisk följt av ett snedstreck (*/):

fnhuvud() {
/*
 Detta är en blockkommentar som sträcker sig över flera rader.
 Det används ofta för att beskriva ett större kodblock.
 */
låta x = 5;
}

Dina kommentarer bör vara kortfattade och raka.

Arrayer i Rust

Matriser är en samling av element av samma datatyp med fast storlek. Rust allokerar arrayer på stacken som standard.

Så här kan du deklarera arrayer i Rust:

fnhuvud() {
låta siffror = [1, 2, 3, 4, 5];
}

De tal arrayen innehåller fem objekt. Du kan komma åt värdet på en plats i en array med hjälp av dess index:

fnhuvud() {
låta siffror = [1, 2, 3, 4, 5];
låta x = siffror[3];
println!("{}", x)
}

De huvud funktionen skriver ut x variabel som kommer åt det fjärde elementet i arrayen.

Vektorer i Rust

Rust tillhandahåller vektorer för att täcka upp arrayens begränsningar. Vektorer har en dynamisk storlek; de kan växa och krympa efter behov.

Så här kan du deklarera vektorer i Rust:

fnhuvud() {
låta min_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
låta x = my_vec[3];
println!("{}", x)
}

De min_vec vektor är en vektor med 32-bitars heltal. De x variabeln får åtkomst till vektorns fjärde element och huvud funktionen skriver ut värdet till konsolen.

Rusts villkorliga uttalanden

Villkorliga uttalanden är ett av Rusts kontrollstrukturer för beslutsfattande i program. Du kan använda om och annan nyckelord för att hantera beslut i dina program.

Här är en om uttalande som skriver ut en sträng till konsolen baserat på två heltal lika.

fnhuvud() {
låta a: i32 = 12;
om a == 12 {
println!("a är lika med tolv");
 }
}

De huvud funktionen skriver ut strängen med println! makro eftersom variabeln är lika med 12.

Du kan använda annan nyckelord för att hantera fall där om påstående utvärderar falskt:

fnhuvud() {
låta a: i32 = 12;
om a == 123 {
println!("a är lika med tolv");
 } annan {
println!("a är inte lika med tolv");
 }
}

I det här exemplet är annan uttalandet körs eftersom a: s värde inte är lika med 123.

Du kan deklarera matchningssatser med match nyckelord för komplexa villkor:

fnhuvud() {
låta ålder: i32 = 7;
match ålder {
1 => println!("ett"),
2 => println!("två"),
3 => println!("tre"),
 _ => println!("noll"),
 }
}

De huvud funktionen matchar ålder variabel till fall i match och exekverar uttrycket som matchar värdet. Understrecket (_) är standardsatsen som körs om det finns en matchning för värdet.

Slingor i Rust

Rust ger öglor för repetitiva uppgifter. Rost har tre huvudtyper av slingor: slinga, medan, och för slingor.

De slinga nyckelordet skapar en oändlig slinga som körs tills den stöter på ett brytnyckelord:

fnhuvud() {
slinga {
println!("skrivs ut upprepade gånger tills break statement påträffas.");
ha sönder;
 }
}

De medan loop är praktiskt när du vill upprepa ett kodblock så länge som ett villkor utvärderas till sant:

fnhuvud() {
låtamut räkna = 0;
medan räkna < 5 {
println!("Antalet är {}", räkna);
 räkna += 1;
 }
}

A för loop är bra för att iterera över en samling objekt, som en array:

fnhuvud() {
låta siffror = [1, 2, 3, 4, 5];
för Artikel i numbers.iter() {
println!("Det aktuella objektet är {}", Artikel);
 }
}

Detta för loop itererar genom tal array och skriver ut varje objekt till konsolen.

Deklarera och anropa rostfunktioner

Använd fn nyckelord till deklarera en Rust-funktion, följt av funktionsnamnet, en lista med parametrar och en returtyp (om någon).

Så här kan du deklarera en funktion med parametrar och en returtyp:

fnLägg till(en: i32, b: i32) -> i32 {
lämna tillbaka a + b;
}

De Lägg till funktionen tar in två 32-bitars heltal och returnerar ett 32-bitars heltal, summan av de två parametrarna.

För att anropa en funktion från någon annanstans i din kod, ange bara namnet och argumenten (om några):

fnhuvud() {
låta resultat = lägg till(2, 3);
println!("2 + 3 = {}", resultat);
}

De resultat variabeln håller resultatet från att anropa Lägg till fungera. De huvud funktionen skriver ut resultatet till konsolen med hjälp av println! makro.

Strukturer i Rust

Rust tillhandahåller strukturer för att definiera anpassade datatyper som grupperar relaterade värden. Strukturer är ritningar för att skapa objekt med specifika egenskaper.

Så här kan du deklarera en struktur:

strukturPerson {
 namn: Sträng,
 ålder: u32,
 is_male: bool,
}

De Person struct har tre fält: en sträng, ett osignerat 32-bitars heltal och ett booleskt.

Efter att ha definierat en struktur kan du skapa instanser av den i andra delar av ditt program:

fnhuvud() {
låta person1 = Person {
 namn: Sträng::från("Candace Flynn"),
 ålder: 16,
 is_male: falsk,
 };
}

De person1 variabel är en instans av Person struktur. Vid instansiering kan du tilldela värden till struct-fälten. Du kan skapa så många instanser av en struktur som du vill.

Du kan implementera OOP-koncept i rost

Rust är flexibelt och du kan implementera OOP-koncepten i Rust med inbyggda datastrukturer som strukturer.

Du kommer att använda strukturer som ett alternativ till klasser. Med Rusts struct kan du definiera en ritning för typen och implementera de olika OOP-koncepten med de funktionaliteter som Rust tillhandahåller på structs.