Result et opérateur ?
Propager les erreurs
Result et opérateur ? est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Le type Result
Result<T, E> représente une opération qui peut réussir avec Ok(T) ou échouer avec Err(E). Il s'agit du type principal de Rust pour gérer les erreurs.
fn main() {
let parsed: Result<i32, _> = "42".parse::<i32>();
println!("{:?}", parsed);
}Faire une correspondance sur Result
Vous pouvez traiter explicitement les deux résultats avec match.
fn main() {
match "oops".parse::<i32>() {
Ok(n) => println!("got {n}"),
Err(e) => println!("error: {e}"),
}
}Renvoyer Result
Les fonctions susceptibles d'échouer renvoient un Result, ce qui permet à l'appelant de décider comment traiter les erreurs.
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));
}L'opérateur ?
L'opérateur ? déballe une valeur Ok ou renvoie rapidement Err depuis la fonction. Il remplace le code verbeux qui combine correspondance et retour.
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"));
}Enchaîner avec ?
Plusieurs étapes susceptibles d'échouer restent claires lorsqu'elles sont enchaînées avec ? ; la première erreur interrompt les suivantes.
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"));
}? dans main
main peut renvoyer un Result, donc ? y fonctionne également. Un Err renvoyé termine le programme avec un code de sortie différent de zéro.
fn main() -> Result<(), std::num::ParseIntError> {
let n: i32 = "100".parse()?;
println!("parsed {n}");
Ok(())
}Méthodes Result utiles
Combinateurs pratiques :
unwrap_or(default)— la valeur ou une solution de replimap— transformer la valeur Okmap_err— transformer l'erreuris_ok/is_err— vérifier la variante
fn main() {
let n = "x".parse::<i32>().unwrap_or(-1);
println!("{n}");
}De Option à Result
Convertissez un Option en Result avec ok_or afin que ? puisse propager une erreur explicite.
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(""));
}Comment ? convertit les erreurs
Lorsque les types d'erreur diffèrent, ? appelle From::from pour convertir l'erreur vers le type d'erreur déclaré par la fonction. Cela permet une gestion pratique des erreurs entre les différentes couches.
Éviter unwrap en production
unwrap et expect déclenchent une panique en cas de Err. Ils conviennent aux exemples et aux tests, mais dans le code réel, préférez ? ou un traitement explicite afin que les échecs restent récupérables.
Enchaîner avec and_then
and_then exécute l'étape suivante susceptible d'échouer uniquement si la précédente a réussi, en transmettant la valeur tout au long de la chaîne.
fn main() {
let result = "8"
.parse::<i32>()
.and_then(|n| Ok(n * 2));
println!("{:?}", result);
}Vérification rapide
Que fait l'opérateur ? lorsqu'il est appliqué à un Result qui vaut Err ?
Récapitulatif
Vous avez appris la gestion des erreurs fondée sur Result :
Result<T, E>modélise la réussite ou l'échec?déballe Ok ou renvoie rapidement Err?fonctionne dans les fonctions et dansmainqui renvoient Result- Les combinateurs comme
map,map_err,unwrap_oretok_orsont utiles - Évitez
unwrapen production
Apprends Rust avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 39
- Leçons
- 144
Questions Fréquemment Posées
La leçon « Result et opérateur ? » est-elle gratuite ?
Oui — le texte complet de « Result et opérateur ? » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Result et opérateur ? » ?
Propager les erreurs Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Result et opérateur ? » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Result et opérateur ?
- thiserror
- anyhow
- Conversion des erreurs