API Entry et valeurs par défaut
Mettez à jour les valeurs de façon ergonomique.
API Entry et valeurs par défaut est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 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 utiliser l’API Entry ?
Souvent, vous souhaitez mettre à jour une valeur si une clé existe, ou insérer une valeur par défaut si elle n’existe pas.
Le faire avec get puis insert est peu pratique. L’API entry le fait proprement en une seule étape.
entry renvoie un emplacement
L’appel à entry(key) vous donne une référence vers l’emplacement de cette clé dans la carte.
À partir de cette référence, vous choisissez quoi faire : la remplir avec une valeur par défaut ou modifier ce qui s’y trouve.
use std::collections::HashMap;
fn main() {
let mut m: HashMap<&str, i32> = HashMap::new();
m.entry("a").or_insert(0);
println!("{}", m["a"]);
}or_insert
or_insert(default) insère la valeur par défaut uniquement si la clé est absente, puis renvoie une référence mutable vers la valeur.
Si la clé existe déjà, la valeur par défaut est ignorée et vous obtenez la valeur existante.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
m.insert("a", 10);
m.entry("a").or_insert(99);
m.entry("b").or_insert(99);
println!("a={}, b={}", m["a"], m["b"]);
}Modifier via la référence
Comme or_insert renvoie une référence mutable, vous pouvez modifier immédiatement la valeur.
Déréférencez-la avec * pour la mettre à jour sur place. C’est le principe central du comptage.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
let count = m.entry("hits").or_insert(0);
*count += 1;
*count += 1;
println!("hits = {}", m["hits"]);
}Compter dans une boucle
Le schéma classique : pour chaque élément, obtenez son emplacement, donnez-lui zéro par défaut, puis incrémentez-le.
Cela permet de comptabiliser les occurrences avec une seule ligne de logique par élément.
use std::collections::HashMap;
fn main() {
let mut counts = HashMap::new();
for c in "hello".chars() {
*counts.entry(c).or_insert(0) += 1;
}
println!("l appears {} times", counts[&'l']);
}or_insert_with
Lorsque la construction de la valeur par défaut coûte cher, utilisez or_insert_with. Cette méthode reçoit une fermeture qui ne s’exécute que si la clé est absente.
Vous évitez ainsi de construire une valeur dont vous pourriez ne jamais avoir besoin.
use std::collections::HashMap;
fn main() {
let mut m: HashMap<&str, Vec<i32>> = HashMap::new();
m.entry("nums").or_insert_with(Vec::new).push(1);
m.entry("nums").or_insert_with(Vec::new).push(2);
println!("{:?}", m["nums"]);
}and_modify
and_modify exécute une fermeture sur la valeur uniquement si la clé existe déjà.
Associez-le à or_insert pour gérer les deux cas : modifier si la clé est présente, sinon insérer une valeur initiale.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
m.insert("x", 5);
m.entry("x").and_modify(|v| *v += 10).or_insert(0);
m.entry("y").and_modify(|v| *v += 10).or_insert(1);
println!("x={}, y={}", m["x"], m["y"]);
}or_default
Si le type de la valeur possède un Default (comme 0 pour les entiers ou un Vec vide), or_default l’utilise.
C’est une forme abrégée de or_insert(Default::default()).
use std::collections::HashMap;
fn main() {
let mut m: HashMap<&str, i32> = HashMap::new();
*m.entry("score").or_default() += 7;
println!("score = {}", m["score"]);
}Construire des listes par clé
L’API entry est particulièrement utile pour regrouper des éléments dans des vecteurs.
Pour chaque clé, utilisez un Vec vide par défaut la première fois, puis ajoutez des éléments au vecteur présent.
use std::collections::HashMap;
fn main() {
let mut groups: HashMap<bool, Vec<i32>> = HashMap::new();
for n in [1, 2, 3, 4] {
groups.entry(n % 2 == 0).or_default().push(n);
}
println!("evens: {:?}", groups[&true]);
}Pourquoi ne pas utiliser get + insert ?
Effectuer un get puis un insert séparé recherche la clé deux fois et se heurte au vérificateur d’emprunts.
L’API entry effectue une seule recherche et vous fournit exactement une référence sûre : elle est donc plus rapide et plus claire.
Assembler le tout
Ici, le comptage et une valeur par défaut sont combinés pour trouver combien de mots distincts commencent par chaque lettre.
Observez le schéma de comptage en une ligne à l’œuvre.
use std::collections::HashMap;
fn main() {
let words = ["ant", "art", "bee"];
let mut by_first: HashMap<char, i32> = HashMap::new();
for w in words {
*by_first.entry(w.chars().next().unwrap()).or_insert(0) += 1;
}
println!("a: {}", by_first[&'a']);
}Vérification rapide
Vous souhaitez compter les chars en effectuant une seule recherche par char.
Récapitulatif
L’API entry vous permet d’insérer ou de mettre à jour une valeur en une seule recherche.
Vous avez utilisé or_insert, or_insert_with, or_default et and_modify pour compter des éléments et construire proprement des listes par clé.
Questions Fréquemment Posées
La leçon « API Entry et valeurs par défaut » est-elle gratuite ?
Oui — le texte complet de « API Entry et valeurs par défaut » 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 « API Entry et valeurs par défaut » ?
Mettez à jour les valeurs de façon ergonomique. 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 2 sur 4.
Combien de temps prend la leçon « API Entry et valeurs par défaut » ?
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
- Construire un HashMap
- API Entry et valeurs par défaut
- Utiliser HashSet
- Compter et regrouper