Förstå funktioner i rost

Funktioner är viktiga programmeringskonstruktioner eftersom de lägger grunden för kodåteranvändbarhet och underlättar modulär programmering. Funktioner är fristående kodblock som utför specifika uppgifter. De kan ta emot input, i form av argument, och returnera ett värde.

Rust tillhandahåller funktioner för kodorganisation, inkapsling och kodåteranvändbarhet.

Definiera funktioner i rost

Rostfunktioner är ungefär som fungerar i något annat programmeringsspråk, även om det finns små skillnader som du måste förstå.

Du kommer att definiera funktioner för dina Rust-program med fn nyckelord följt av funktionsnamnet, valfria argument och en valfri retur data typ.

// funktion som varken tar in argument eller returnerar ett värde
fn funktionsnamn() {
// funktionskropp här
}

Här är en enkel Rust-funktion som inte tar in några argument eller returnerar några värden.

fn a_function(){
 låt x = 3;
println!("{}", x)
}

en funktion är en enkel Rust-funktion som skriver ut variabeln x.

Rostfunktionssignaturer

Funktionssignaturer är ett sätt att namnge funktioner och beskriva deras argument och returtyper, utan att inkludera en funktionskropp. Funktionssignaturer är användbara för att dokumentera API: er för Rust-bibliotek.

Här är ett exempel på en rostfunktionssignatur:

fn namn()
fn-hälsning (namn: &str)

De namn funktion är en minimal funktionssignatur, medan hälsa signatur anger att funktionen tar ett enda argument, namn, av typen sträng (&str).

Deklarera funktioner med argument och returvärden

Rostfunktioner kan ta in många argument, och gränsen är inte explicit definierad. Funktioner med argument är i allmänhet mer flexibla eftersom de kan ta in värden från andra funktioner och delar av koden.

Här är den typiska modellen av en Rust-funktion som tar in argument:

fn funktionsnamn (arg: typ, arg2: typ) {
// funktionskropp här
}

Funktionsargumenttypen kan vara en Rust inbyggd typ eller en anpassad typ från ditt program.

Här är ett exempel på en enkel funktion som tar två heltal som argument:

fn add_numbers (x: i32, y: i32) {
println!("{}"x + y);
}

De add_numbers funktionen tar in två 32-bitars heltal och skriver ut summan av heltal.

Rostfunktioner kan returnera flera värden; du måste ange returtyp(er) och returnera värdena för typen från funktionen.

fn funktionsnamn (arg: typ, arg2: typ) -> (typ, typ) {
// funktionskropp här
lämna tillbaka arg, arg2
}

Här är en funktion som tar in en sträng och ett 32-bitars heltal som ett argument och returnerar argumenten som en tupel.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
lämna tillbaka (s, n);
}

De sträng_och_heltal funktionen tar in en sträng och ett 32-bitars heltal och returnerar dem som en tupel. Du kan bara returnera ett enda värde från en Rust-funktion.

Du kan utelämna lämna tillbaka nyckelord när det slutliga uttrycket returneras från en funktion, för att göra koden mer kortfattad.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
lämna tillbaka (s, n);
}
// funktionerna är likvärdiga
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Dessa två funktioner har samma beteende eftersom de båda tar in en sträng och ett heltal och returnerar dessa argument som en tupel.

Anropa Rust Functions

Du kan anropa en funktion från en annan genom att skriva dess namn följt av värden som du vill skicka till den inom parentes:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn main() {
 låt resultat = add_numbers(3, 5);
println!("Resultatet är {}", resultat); // Utdata: Resultatet är 8
}

De huvud funktionsanrop add_numbers, skickar det två heltal. Den tilldelar resultatet av funktionen till en variabel, resultat.

Du kan deklarera funktioner för rostkonstruktioner

Du kan deklarera funktioner inom Rust-strukturer. Dessa blir metoder för strukturen som kan komma åt och ändra den.

Rust är inte rent objektorienterat, men det ger strukturer för att gruppera relaterade data. Du kan arbeta för att implementera OOP-koncept i Rust med hjälp av strukturer med metoder.