Closures
Anonyme funktioner
Closures er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.
Hvad er en lukning?
En lukning er en anonym funktion, som du kan gemme i en variabel og kalde senere. Den skrives med lodrette streger omkring parametrene.
fn main() {
let add_one = |x| x + 1;
println!("{}", add_one(4));
}Lukningssyntaks
Parametrene står mellem |...|, efterfulgt af kroppen. Hvis kroppen kun indeholder ét udtryk, er krøllede parenteser ikke nødvendige.
|x| x + 1– én parameter.|a, b| a + b– to parametre.
fn main() {
let multiply = |a, b| a * b;
println!("{}", multiply(3, 5));
}Lukninger over flere linjer
Hvis kroppen indeholder mere end én sætning, skal du omslutte den med krøllede parenteser ligesom en funktion.
fn main() {
let describe = |n: i32| {
let doubled = n * 2;
println!("{} doubled is {}", n, doubled);
};
describe(7);
}Indfangning af omgivelserne
I modsætning til en almindelig funktion kan en closure indfange variabler fra det omgivende scope og bruge dem indeni.
fn main() {
let factor = 10;
let scale = |x| x * factor;
println!("{}", scale(5));
}Typ inferens i closures
Closures udleder normalt deres parameter- og returtyper ud fra, hvordan de bruges, så annoteringer er valgfri.
Du kan tilføje typer for tydelighedens skyld, når det er nødvendigt.
fn main() {
let greet = |name: &str| -> String {
format!("Hello, {}!", name)
};
println!("{}", greet("Rust"));
}Closures som argumenter
Mange standardmetoder accepterer en closure. For eksempel anvender map en closure på hvert element.
fn main() {
let nums = vec![1, 2, 3];
let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
println!("{:?}", doubled);
}Filtrering med closures
Metoden filter beholder kun de elementer, som closuren returnerer true for.
fn main() {
let nums = vec![1, 2, 3, 4, 5, 6];
let evens: Vec<i32> = nums.into_iter().filter(|x| x % 2 == 0).collect();
println!("{:?}", evens);
}Lagring af closures
Closures har unikke anonyme typer, men du kan gemme dem i en variabel og genbruge dem.
fn main() {
let is_even = |n: i32| n % 2 == 0;
println!("{} {}", is_even(4), is_even(7));
}Closures sammenlignet med funktioner
Forskelle:
- Funktioner kan ikke indfange omgivende variabler; det kan closures.
- Closures er anonyme og ofte korte.
- Closure-typer udledes normalt.
fn main() {
let base = 100;
let bonus = |earned: i32| earned + base;
println!("{}", bonus(25));
}Returnering af beregnede værdier
Kombinér closures med iteratorer for at beregne resultater i en ren og udtryksfuld pipeline.
fn main() {
let nums = vec![10, 20, 30];
let total: i32 = nums.iter().map(|x| x + 1).sum();
println!("total {}", total);
}Closures indfanger ved reference
Som standard låner en closure de indfangede variabler. Du kan stadig læse dem bagefter uden for closuren, når de kun er lånt.
fn main() {
let name = String::from("Ada");
let printer = || println!("Name: {}", name);
printer();
println!("still usable: {}", name);
}Hurtigt tjek
Genkald en vigtig egenskab ved closures.
Opsummering
Closures i Rust:
- Anonyme funktioner skrevet som
|params| body. - Kan indfange variabler fra deres miljø.
- Typer udledes normalt.
- Bruges meget sammen med iteratormetoder som
mapogfilter.
fn main() {
let tax = 0.2;
let with_tax = |price: f64| price * (1.0 + tax);
println!("{}", with_tax(50.0));
}
Lær Rust med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 39
- Lektioner
- 144
Ofte stillede spørgsmål
Er lektionen “Closures” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Closures”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Closures”?
Anonyme funktioner Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Lær at programmere i Rust?
Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Closures”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?
Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.