Forstå funksjoner i rust

Funksjoner er essensielle programmeringskonstruksjoner siden de legger grunnlaget for gjenbruk av kode og letter modulær programmering. Funksjoner er selvstendige blokker med kode som utfører spesifikke oppgaver. De kan motta input, i form av argumenter, og returnere en verdi.

Rust gir funksjoner for kodeorganisering, innkapsling og gjenbruk av kode.

Definere funksjoner i rust

Rust funksjoner er mye som funksjoner på et hvilket som helst annet programmeringsspråk, selv om det er små forskjeller du må forstå.

Du vil definere funksjoner for Rust-programmene dine med fn nøkkelord etterfulgt av funksjonsnavnet, valgfrie argumenter og en valgfri retur data-type.

// funksjon som verken tar inn argumenter eller returnerer en verdi
fn funksjonsnavn() {
// funksjonskropp her
}

Her er en enkel Rust-funksjon som ikke tar inn noen argumenter eller returnerer noen verdier.

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

en_funksjon er en enkel Rust-funksjon som skriver ut variabelen x.

Rustfunksjonssignaturer

Funksjonssignaturer er en måte å navngi funksjoner, og beskrive deres argumenter og returtyper, uten å inkludere en funksjonskropp. Funksjonssignaturer er nyttige for å dokumentere API-er for Rust-biblioteker.

Her er et eksempel på rustfunksjonssignatur:

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

De Navn funksjon er en minimal funksjonssignatur, mens hilse på signatur spesifiserer at funksjonen tar et enkelt argument, Navn, av typen streng (&str).

Erklære funksjoner med argumenter og returverdier

Rustfunksjoner kan ta inn mange argumenter, og grensen er ikke eksplisitt definert. Funksjoner med argumenter er generelt mer fleksible siden de kan ta inn verdier fra andre funksjoner og deler av koden.

Her er den typiske modellen av en Rust-funksjon som tar inn argumenter:

fn funksjonsnavn (arg: type, arg2: type) {
// funksjonskropp her
}

Funksjonsargumenttypen kan være en Rust innebygd type eller en tilpasset type fra programmet ditt.

Her er et eksempel på en enkel funksjon som tar to heltall som argumenter:

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

De add_numbers funksjonen tar inn to 32-biters heltall og skriver ut summen av heltallene.

Rustfunksjoner kan returnere flere verdier; du må spesifisere returtypen(e) og returnere verdiene til typen fra funksjonen.

fn funksjonsnavn (arg: type, arg2: type) -> (type, type) {
// funksjonskropp her
komme tilbake arg, arg2
}

Her er en funksjon som tar inn en streng og et 32-bits heltall som et argument og returnerer argumentene som en tuppel.

fn streng_og_heltall (s: streng, n: i32) -> (streng, i32) {
komme tilbake (s, n);
}

De streng_og_heltall funksjonen tar inn en streng og et 32-bits heltall, og returnerer dem som en tuppel. Du kan bare returnere én enkelt verdi fra en Rust-funksjon.

Du kan utelate komme tilbake nøkkelord når du returnerer det endelige uttrykket fra en funksjon, for å gjøre koden mer kortfattet.

fn streng_og_heltall (s: streng, n: i32) -> (streng, i32) {
komme tilbake (s, n);
}
// funksjonene er likeverdige
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Disse to funksjonene har samme oppførsel siden de begge tar inn en streng og heltall og returnerer disse argumentene som en tuppel.

Kaller rustfunksjoner

Du kan kalle en funksjon fra en annen ved å skrive navnet etterfulgt av verdier du vil overføre til den innenfor parentes:

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

De hoved- funksjonsanrop add_numbers, og sender det to heltall. Den tilordner resultatet av funksjonen til en variabel, resultat.

Du kan deklarere funksjoner for ruststrukturer

Du kan deklarere funksjoner i Rust-strukturer. Disse blir metoder for strukturen som kan få tilgang til og endre den.

Rust er ikke rent objektorientert, men det gir strukturer for å gruppere relaterte data. Du kan jobbe mot å implementere OOP-konsepter i Rust ved hjelp av strukturer med metoder.