Règles d’omission
Quand les durées de vie sont déduites
Règles d’omission 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.
Les durées de vie que vous n'écrivez pas
De nombreuses fonctions prennent et renvoient des références sans aucune annotation de durée de vie, tout en étant compilées. Cela est possible grâce à l'omission des durées de vie : le compilateur déduit pour vous les durées de vie évidentes.
L'omission est simplement un raccourci
L'omission ne supprime pas les durées de vie ; le compilateur les complète toujours en arrière-plan à l'aide de quelques règles déterministes. Lorsque ces règles couvrent votre cas, vous pouvez omettre les annotations.
Une fonction avec durée de vie omise
Cette fonction ne comporte aucune durée de vie explicite, mais le compilateur comprend que la référence renvoyée emprunte à l'entrée. Les règles rendent cela sans ambiguïté.
fn first_word(s: &str) -> &str {
s.split(' ').next().unwrap_or("")
}
fn main() {
let phrase = String::from("rust is fun");
println!("{}", first_word(&phrase));
}Règle 1 : chaque entrée reçoit la sienne
Première règle : chaque durée de vie omise dans les paramètres reçoit une durée de vie distincte. Deux paramètres de référence reçoivent donc deux durées de vie séparées.
Règle 2 : une entrée, une sortie
Deuxième règle : lorsqu'il existe exactement une durée de vie d'entrée, elle est attribuée à toutes les durées de vie de sortie. Cela couvre les fonctions comme first_word, qui prennent et renvoient une seule référence.
fn trim_start(s: &str) -> &str {
s.trim_start()
}
fn main() {
println!("[{}]", trim_start(" hi"));
}Règle 3 : méthodes et &self
Troisième règle : si une méthode possède &self ou &mut self, la durée de vie de self est attribuée à toutes les durées de vie en sortie. C’est pourquoi les méthodes nécessitent rarement des annotations.
struct Holder { value: String }
impl Holder {
fn get(&self) -> &str {
&self.value
}
}
fn main() {
let h = Holder { value: String::from("stored") };
println!("{}", h.get());
}Quand l’élision échoue
Après l’application des trois règles, si une durée de vie en sortie reste inconnue, le compilateur vous demande de l’annoter explicitement. La fonction longest en est le cas classique : deux entrées et une sortie ambiguë.
La fonction longest, encore une fois
Deux références en entrée et une référence en sortie : la règle 2 ne s’applique pas (il y a plus d’une entrée) et il n’y a pas de self. Vous devez donc ajouter une annotation.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
fn main() {
println!("{}", longest("abcd", "ab"));
}Plusieurs entrées, sortie issue de self
Selon la règle 3, une méthode comportant plusieurs paramètres obtient tout de même la durée de vie de sa sortie à partir de self, même si d’autres paramètres de type référence existent.
struct Doc { body: String }
impl Doc {
fn announce(&self, _note: &str) -> &str {
&self.body
}
}
fn main() {
let d = Doc { body: String::from("content") };
println!("{}", d.announce("ping"));
}Pourquoi ces règles existent
Ces trois règles couvrent l’immense majorité du code réel. La plupart des fonctions n’ont donc besoin d’aucune syntaxe de durée de vie. Vous n’ajoutez des annotations que lorsque l’intention est réellement ambiguë.
Une liste de vérification rapide
Pour déterminer si l’élision s’applique, posez-vous les questions suivantes :
- Y a-t-il exactement une référence en entrée ? La sortie l’emprunte.
- Y a-t-il un
&self? La sortie emprunte à self. - Sinon, ajoutez une annotation explicite.
Vérification rapide
Vérifiez votre compréhension des règles d’élision.
Récapitulatif
Vous avez appris quand les durées de vie sont déduites :
- Règle 1 : chaque référence en entrée reçoit sa propre durée de vie
- Règle 2 : une durée de vie en entrée est associée à toutes les sorties
- Règle 3 :
&selffournit la durée de vie de sortie dans les méthodes - Si les sorties restent ambiguës, vous ajoutez une annotation explicite
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 « Règles d’omission » est-elle gratuite ?
Oui — le texte complet de « Règles d’omission » 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 « Règles d’omission » ?
Quand les durées de vie sont déduites 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 « Règles d’omission » ?
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
- Pourquoi les durées de vie
- Annotations de durée de vie
- Durées de vie dans les structures
- Règles d’omission