Learn Rust Coding · Leçon

Construire un HashMap

Insérez et recherchez par clé.

Construire un HashMap 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.

Qu’est-ce qu’un HashMap ?

Un HashMap stocke des données sous forme de paires clé-valeur. Vous effectuez les recherches à l’aide d’une clé plutôt que d’un index.

Imaginez un annuaire téléphonique : un nom (la clé) correspond à un numéro (la valeur). Les HashMaps sont parfaits lorsque vous avez besoin de recherches rapides à partir d’une clé significative.

Importer HashMap

Contrairement à Vec et String, HashMap ne fait pas partie du prélude. Vous devez l’importer dans la portée courante.

Ajoutez une ligne use en haut de votre fichier. Le nom sera ainsi disponible dans tout le module.

use std::collections::HashMap;

fn main() {
    let scores: HashMap<String, i32> = HashMap::new();
    println!("empty map len: {}", scores.len());
}

Insérer des paires

Utilisez insert pour ajouter une clé et sa valeur. Si la clé existe déjà, l’ancienne valeur est remplacée.

La carte doit être déclarée avec mut pour permettre les insertions.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 50);
    scores.insert("Bob", 30);
    println!("{} players", scores.len());
}

Inférence de type

Vous devez rarement écrire le type. Rust déduit HashMap<&str, i32> à partir des premiers appels à insert.

Ici, les clés sont des tranches de chaînes et les valeurs sont des entiers : tout est déterminé par l’utilisation.

use std::collections::HashMap;

fn main() {
    let mut ages = HashMap::new();
    ages.insert("Sam", 28);
    ages.insert("Mia", 34);
    println!("Sam is {}", ages["Sam"]);
}

Obtenir des valeurs

La méthode get renvoie un Option. Vous obtenez Some(&value) si la clé existe, ou None dans le cas contraire.

Cela vous oblige à gérer correctement le cas où la clé est absente.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 50);
    match scores.get("Alice") {
        Some(v) => println!("score: {}", v),
        None => println!("no score"),
    }
}

Indexation ou get

Vous pouvez utiliser l’indexation avec map[key], mais cela déclenche une panique si la clé est absente.

Préférez get lorsqu’une clé peut ne pas exister. Utilisez l’indexation uniquement lorsque vous êtes certain que la clé est présente.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("x", 1);
    // m["y"] would panic!
    let v = m.get("y").copied().unwrap_or(0);
    println!("y = {}", v);
}

Mettre à jour une valeur

Appeler insert avec une clé existante écrase l’ancienne valeur.

La valeur précédente est renvoyée (encapsulée dans Option) afin que vous puissiez l’examiner si vous le souhaitez.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("k", 1);
    let old = m.insert("k", 9);
    println!("old = {:?}, now = {}", old, m["k"]);
}

Vérifier les clés

Utilisez contains_key pour vérifier qu’une clé existe sans récupérer sa valeur.

La méthode renvoie un simple bool, ce qui est pratique dans les conditions if.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("on", true);
    if m.contains_key("on") {
        println!("key exists");
    }
}

Supprimer des entrées

La méthode remove supprime une clé et renvoie sa valeur sous la forme d’un Option.

Si la clé n’était pas présente, vous obtenez None : la suppression est donc toujours sûre.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a", 1);
    let removed = m.remove("a");
    println!("removed {:?}, len {}", removed, m.len());
}

Parcourir une carte

Une boucle for sur un HashMap produit des tuples (key, value) par référence.

Notez que l’ordre n’est pas défini et peut changer d’une exécution à l’autre, car le hachage brouille le placement.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a", 1);
    m.insert("b", 2);
    for (k, v) in &m {
        println!("{} -> {}", k, v);
    }
}

Propriété des clés

Lorsque vous insérez des valeurs possédées comme une String, la carte en prend la propriété.

Après l’insertion, vous ne pouvez plus utiliser cette variable, sauf si vous l’avez d’abord clonée.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    let name = String::from("Alice");
    m.insert(name, 50);
    // name is moved here; m owns it now
    println!("{}", m["Alice"]);
}

Vérification rapide

Vous voulez obtenir une valeur, mais la clé peut être absente.

Récapitulatif

Vous avez appris à créer un HashMap, à insérer des paires et à rechercher des valeurs avec get ou l’indexation.

Vous avez également découvert contains_key, remove, le parcours et la manière dont la carte prend la propriété des clés insérées.

Questions Fréquemment Posées

La leçon « Construire un HashMap » est-elle gratuite ?

Oui — le texte complet de « Construire un HashMap » 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 « Construire un HashMap » ?

Insérez et recherchez par clé. 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 « Construire un HashMap » ?

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

← Retour à Learn Rust Coding