Closures
Anonyma funktioner
Closures är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad är en closure?
En closure är en namnlös funktion som ni kan lagra i en variabel och anropa senare. Den skrivs med lodräta streck runt parametrarna.
fn main() {
let add_one = |x| x + 1;
println!("{}", add_one(4));
}Closure-syntax
Parametrarna placeras mellan |...|, följda av kroppen. För ett enda uttryck behövs inga klammerparenteser.
|x| x + 1— en parameter.|a, b| a + b— två parametrar.
fn main() {
let multiply = |a, b| a * b;
println!("{}", multiply(3, 5));
}Closure över flera rader
Om kroppen innehåller mer än en sats omsluter ni den med klammerparenteser, precis som för en funktion.
fn main() {
let describe = |n: i32| {
let doubled = n * 2;
println!("{} doubled is {}", n, doubled);
};
describe(7);
}Fånga omgivningen
Till skillnad från en vanlig funktion kan en closure fånga variabler från det omgivande scopet och använda dem inuti sig.
fn main() {
let factor = 10;
let scale = |x| x * factor;
println!("{}", scale(5));
}Typhärledning i closures
Closures härleder vanligtvis sina parameter- och returtyper utifrån hur de används, så typannoteringar är valfria.
Ni kan lägga till typer för tydlighet när det behövs.
fn main() {
let greet = |name: &str| -> String {
format!("Hello, {}!", name)
};
println!("{}", greet("Rust"));
}Closures som argument
Många standardmetoder tar emot en closure. Till exempel tillämpar map en closure på varje 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 behåller endast de element för vilka closuren returnerar true.
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);
}Lagra closures
Closures har unika anonyma typer, men ni kan lagra dem i en variabel och återanvända dem.
fn main() {
let is_even = |n: i32| n % 2 == 0;
println!("{} {}", is_even(4), is_even(7));
}Closures jämfört med funktioner
Skillnader:
- Funktioner kan inte fånga omgivande variabler, men det kan closures.
- Closures är anonyma och ofta korta.
- Closure-typer härleds vanligtvis.
fn main() {
let base = 100;
let bonus = |earned: i32| earned + base;
println!("{}", bonus(25));
}Returnera beräknade värden
Kombinera closures med iteratorer för att beräkna resultat i en ren och uttrycksfull pipeline.
fn main() {
let nums = vec![10, 20, 30];
let total: i32 = nums.iter().map(|x| x + 1).sum();
println!("total {}", total);
}Closures fångar genom referens
Som standard lånar en closure de fångade variablerna. Ni kan fortfarande läsa dem utanför efteråt (när de endast lånades).
fn main() {
let name = String::from("Ada");
let printer = || println!("Name: {}", name);
printer();
println!("still usable: {}", name);
}Snabb kontroll
Kom ihåg en viktig egenskap hos closures.
Sammanfattning
Closures i Rust:
- Anonyma funktioner som skrivs som
|params| body. - Kan fånga variabler från sin omgivning.
- Typer härleds vanligtvis.
- Används ofta tillsammans med iteratormetoder som
mapochfilter.
fn main() {
let tax = 0.2;
let with_tax = |price: f64| price * (1.0 + tax);
println!("{}", with_tax(50.0));
}
Lär dig Rust med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Closures” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Closures”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad lär jag mig i ”Closures”?
Anonyma funktioner Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?
Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Closures”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?
Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.