Conversion des erreurs
Implémentations de From
Conversion des erreurs est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 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.
Pourquoi convertir les erreurs ?
Les différentes couches du code produisent différents types d’erreurs. Pour les propager au travers d’une seule fonction, vous devez convertir les erreurs de bas niveau en un type unifié. Rust effectue cette conversion avec le trait From.
Le trait From
From<T> définit comment construire un type à partir d’un autre. Son implémentation pour votre type d’erreur vous permet de convertir les erreurs sources en ce type.
trait From<T> {
fn from(value: T) -> Self;
}Comment ? utilise From
Lorsque vous écrivez expr? et que le type d’erreur diffère de celui renvoyé par la fonction, l’opérateur appelle From::from pour effectuer la conversion. C’est ce qui permet cette propagation fluide.
Un type d’erreur unifié
Définissez une énumération capable de contenir chaque type d’erreur que votre fonction peut produire.
#[derive(Debug)]
enum AppError {
Io(std::io::Error),
Parse(std::num::ParseIntError),
}Implémenter From
Écrivez une implémentation de From pour chaque erreur source afin de la convertir en variante correspondante.
impl From<std::io::Error> for AppError {
fn from(e: std::io::Error) -> Self {
AppError::Io(e)
}
}
impl From<std::num::ParseIntError> for AppError {
fn from(e: std::num::ParseIntError) -> Self {
AppError::Parse(e)
}
}Propagation automatique
Une fois ces implémentations en place, ? convertit gratuitement chaque erreur en AppError.
fn read_count(path: &str) -> Result<i32, AppError> {
let text = std::fs::read_to_string(path)?; // io::Error -> AppError
let n: i32 = text.trim().parse()?; // ParseIntError -> AppError
Ok(n)
}Into est le miroir
L’implémentation de From<A> for B vous fournit automatiquement A: Into<B>. Préférez implémenter From : vous obtenez into() gratuitement.
fn make() -> AppError {
let e: std::io::Error = std::io::Error::other("boom");
e.into() // uses From<io::Error> for AppError
}Encapsuler des objets de trait
Pour des conversions rapides, Box<dyn Error> accepte tout type d’erreur, car la bibliothèque standard fournit des implémentations génériques de From vers celui-ci.
use std::error::Error;
fn run() -> Result<(), Box<dyn Error>> {
let n: i32 = "42".parse()?; // ParseIntError -> Box<dyn Error>
println!("{n}");
Ok(())
}Caisses qui génèrent From
Écrire chaque implémentation de From à la main est fastidieux. L’attribut #[from] de thiserror les génère, tandis que anyhow convertit automatiquement toutes les erreurs en un seul type.
Choisir une approche
Résumé des stratégies de conversion :
- Implémentations manuelles de
From— contrôle total, davantage de code thiserror #[from]— erreurs typées, implémentations généréesBox<dyn Error>ouanyhow— cérémonial minimal
Ajouter un contexte pendant la conversion
Une implémentation de From peut faire plus qu’envelopper une erreur : elle peut l’enrichir. Ici, la conversion ajoute un contexte supplémentaire afin que l’erreur finale soit plus informative.
impl From<std::num::ParseIntError> for AppError {
fn from(e: std::num::ParseIntError) -> Self {
// could log or annotate here before wrapping
AppError::Parse(e)
}
}Vérification rapide
Quel trait l’opérateur ? utilise-t-il pour convertir un type d’erreur en un autre ?
Récapitulatif
Vous avez découvert la conversion des erreurs :
?convertit les erreurs via le traitFrom- Implémentez
From<Source>pour votre énumération d’erreurs Fromvous fournit gratuitementIntoetinto()Box<dyn Error>accepte toute erreurthiserroretanyhowautomatisent le code répétitif
Questions Fréquemment Posées
La leçon « Conversion des erreurs » est-elle gratuite ?
Oui — le texte complet de « Conversion des erreurs » 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 « Conversion des erreurs » ?
Implémentations de From 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 4 sur 4.
Combien de temps prend la leçon « Conversion des erreurs » ?
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