Forståelse af funktioner i rust

Funktioner er essentielle programmeringskonstruktioner, da de lægger grundlaget for genbrug af kode og letter modulær programmering. Funktioner er selvstændige kodeblokke, der udfører specifikke opgaver. De kan modtage input i form af argumenter og returnere en værdi.

Rust leverer funktioner til kodeorganisering, indkapsling og kodegenanvendelighed.

Definition af funktioner i rust

Rustfunktioner ligner meget funktioner i et hvilket som helst andet programmeringssprog, selvom der er små forskelle, du bliver nødt til at forstå.

Du definerer funktioner til dine Rust-programmer med fn nøgleord efterfulgt af funktionsnavnet, valgfrie argumenter og et valgfrit retur datatype.

// funktion, der hverken tager argumenter ind eller returnerer en værdi
fn funktionsnavn() {
// funktion krop her
}

Her er en simpel Rust-funktion, der ikke tager nogen argumenter ind eller returnerer nogen værdier.

fn a_function(){
 lad x = 3;
println!("{}", x)
}

a_funktion er en simpel Rust-funktion, der udskriver variablen x.

Rustfunktionssignaturer

Funktionssignaturer er en måde at navngive funktioner på og beskrive deres argumenter og returtyper uden at inkludere en funktionstekst. Funktionssignaturer er nyttige til at dokumentere API'er af Rust-biblioteker.

Her er et eksempel på en rustfunktionssignatur:

fn navn()
fn hilsen (navn: &str)

Det navn funktion er en minimal funktionssignatur, mens hilse signatur angiver, at funktionen tager et enkelt argument, navn, af typen streng (&str).

Erklæring af funktioner med argumenter og returværdier

Rustfunktioner kan tage mange argumenter ind, og grænsen er ikke eksplicit defineret. Funktioner med argumenter er generelt mere fleksible, da de kan indtage værdier fra andre funktioner og dele af koden.

Her er den typiske model af en Rust-funktion, der tager argumenter ind:

fn funktionsnavn (arg: type, arg2: type) {
// funktion krop her
}

Funktionsargumenttypen kan være en Rust indbygget type eller en brugerdefineret type fra dit program.

Her er et eksempel på en simpel funktion, der tager to heltal som argumenter:

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

Det tilføje_numre funktionen tager to 32-bit heltal ind og udskriver summen af ​​heltal.

Rustfunktioner kan returnere flere værdier; du bliver nødt til at angive returtypen(e) og returnere værdierne for typen fra funktionen.

fn funktionsnavn (arg: type, arg2: type) -> (type, type) {
// funktion krop her
Vend tilbage arg, arg2
}

Her er en funktion, der tager en streng og et 32-bit heltal ind som et argument og returnerer argumenterne som en tupel.

fn streng_og_heltal (s: streng, n: i32) -> (streng, i32) {
Vend tilbage (s, n);
}

Det streng_og_heltal funktionen tager en streng og et 32-bit heltal ind og returnerer dem som en tupel. Du kan kun returnere en enkelt værdi fra en Rust-funktion.

Du kan udelade Vend tilbage nøgleord, når det endelige udtryk returneres fra en funktion, for at gøre koden mere kortfattet.

fn streng_og_heltal (s: streng, n: i32) -> (streng, i32) {
Vend tilbage (s, n);
}
// funktionerne er ækvivalente
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Disse to funktioner har den samme adfærd, da de begge optager en streng og heltal og returnerer disse argumenter som en tupel.

Kalder rustfunktioner

Du kan kalde en funktion fra en anden ved at skrive dens navn efterfulgt af værdier, du vil overføre til den inden for parentes:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn main() {
 lad resultat = add_numbers(3, 5);
println!("Resultatet er {}", resultat); // Output: Resultatet er 8
}

Det vigtigste funktionskald tilføje_numre, og giver det to heltal. Den tildeler resultatet af funktionen til en variabel, resultat.

Du kan erklære funktioner for ruststrukturer

Du kan erklære funktioner i Rust-strukturer. Disse bliver metoder til strukturen, der kan få adgang til og ændre den.

Rust er ikke rent objektorienteret, men det giver strukturer til at gruppere relaterede data. Du kan arbejde hen imod implementering af OOP-koncepter i Rust ved hjælp af strukturer med metoder.