Result en de ?-operator
Fouten doorgeven
Result en de ?-operator is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 4 lessen.
Het type Result
Result<T, E> staat voor een bewerking die kan slagen met Ok(T) of kan mislukken met Err(E). Het is het belangrijkste type van Rust voor foutafhandeling.
fn main() {
let parsed: Result<i32, _> = "42".parse::<i32>();
println!("{:?}", parsed);
}Result matchen
Je kunt beide uitkomsten expliciet afhandelen met match.
fn main() {
match "oops".parse::<i32>() {
Ok(n) => println!("got {n}"),
Err(e) => println!("error: {e}"),
}
}Result retourneren
Functies die kunnen mislukken retourneren een Result, zodat de aanroeper kan bepalen hoe fouten worden afgehandeld.
fn halve(n: i32) -> Result<i32, String> {
if n % 2 == 0 {
Ok(n / 2)
} else {
Err("odd number".to_string())
}
}
fn main() {
println!("{:?}", halve(10));
println!("{:?}", halve(7));
}De ?-operator
De operator ? pakt een Ok-waarde uit of retourneert vroegtijdig de Err uit de functie. Daarmee vervang je omslachtige match-en-retourneer-code.
fn double_str(s: &str) -> Result<i32, std::num::ParseIntError> {
let n = s.parse::<i32>()?;
Ok(n * 2)
}
fn main() {
println!("{:?}", double_str("21"));
println!("{:?}", double_str("x"));
}Koppelen met ?
Meerdere stappen die kunnen mislukken zijn overzichtelijk wanneer je ze met ? koppelt; de eerste fout breekt de rest vroegtijdig af.
fn sum_two(a: &str, b: &str) -> Result<i32, std::num::ParseIntError> {
let x = a.parse::<i32>()?;
let y = b.parse::<i32>()?;
Ok(x + y)
}
fn main() {
println!("{:?}", sum_two("3", "4"));
}? in main
main kan een Result retourneren, dus ? werkt daar ook. Een geretourneerde Err beëindigt het programma met een exitcode die niet nul is.
fn main() -> Result<(), std::num::ParseIntError> {
let n: i32 = "100".parse()?;
println!("parsed {n}");
Ok(())
}Handige Result-methoden
Handige combinators:
unwrap_or(default)— waarde of terugvalwaardemap— transformeer de Ok-waardemap_err— transformeer de foutis_ok/is_err— controleer de variant
fn main() {
let n = "x".parse::<i32>().unwrap_or(-1);
println!("{n}");
}Option naar Result
Converteer een Option naar een Result met ok_or, zodat ? een betekenisvolle fout kan doorgeven.
fn first_char(s: &str) -> Result<char, String> {
let c = s.chars().next().ok_or("empty string".to_string())?;
Ok(c)
}
fn main() {
println!("{:?}", first_char("hi"));
println!("{:?}", first_char(""));
}Hoe ? fouten converteert
Wanneer de fouttypen verschillen, roept ? From::from aan om de fout te converteren naar het gedeclareerde fouttype van de functie. Dit maakt ergonomische foutafhandeling over verschillende lagen mogelijk.
Vermijd unwrap in productiecode
unwrap en expect veroorzaken een panic bij Err. Ze zijn prima voor voorbeelden en tests, maar gebruik in echte code liever ? of expliciete afhandeling, zodat fouten herstelbaar blijven.
Koppelen met and_then
and_then voert de volgende stap die kan mislukken alleen uit als de vorige is geslaagd en geeft de waarde daarbij door.
fn main() {
let result = "8"
.parse::<i32>()
.and_then(|n| Ok(n * 2));
println!("{:?}", result);
}Korte controle
Wat doet de operator ? wanneer je deze toepast op een Result die Err is?
Samenvatting
U hebt foutafhandeling op basis van Result geleerd:
Result<T, E>modelleert succes of mislukking?pakt Ok uit of geeft vroegtijdig Err terug?werkt in functies en inmaindie Result teruggeven- Combinators zoals
map,map_err,unwrap_orenok_orzijn nuttig - Vermijd
unwrapin productie
Leer Rust met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 144
Veelgestelde vragen
Is de les “Result en de ?-operator” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Result en de ?-operator”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 4 lessen.
Wat leer ik in “Result en de ?-operator”?
Fouten doorgeven Je oefent met Leer programmeren met Rust door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Leer programmeren met Rust te beginnen?
Ervaring vooraf is niet nodig. Leer programmeren met Rust op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Result en de ?-operator”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Leer programmeren met Rust?
Ja. Elke les over Leer programmeren met Rust bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Result en de ?-operator
- thiserror
- anyhow
- Fouten converteren