HashMap en Rust 2025 : littéraux, macros et meilleures pratiques

Créer un HashMap en Rust : de la douleur à la beauté en 2025

Si vous avez déjà programmé en Rust et vous êtes demandé "How do I create a HashMap literal?" — vous n'êtes pas seul. Cette question sur Stack Overflow a recueilli des milliers de vues, et pour cause. Dans des langages comme Python ou JavaScript, créer un dictionnaire se résume à quelques accolades. En Rust, c'est un peu plus complexe… mais seulement à première vue.

En 2025, l'écosystème Rust a fait un bond en avant. De nouvelles macros sont apparues, le travail avec les constantes s'est amélioré, et le compilateur est devenu encore plus intelligent. Dans cet article, nous allons passer en revue toutes les méthodes de création d'un HashMap, des plus classiques aux plus modernes. Vous apprendrez à écrire non seulement un code fonctionnel, mais aussi un code élégant et efficace.

C'est parti ! 🦀

Pourquoi Rust n'a-t-il pas de littéral HashMap intégré ?

C'est sans doute la question la plus fréquente des débutants. La réponse est simple : Rust n'est pas Python. Rust n'a pas de "magie" syntaxique pour les collections, car le langage vise la prévisibilité et le contrôle de la mémoire.

Imaginez que vous écrivez :

let map = {"key1": "value1", "key2": "value2"};

Cela semble logique ? Oui. Mais que faire si les clés ou les valeurs ne sont pas des chaînes, mais des structures complexes ? Comment le compilateur saurait-il quel allocateur utiliser ? Et le hachage ? Rust laisse ces décisions au développeur.

C'est pourquoi, pour créer un HashMap dans la bibliothèque standard, on utilise HashMap::new() et les méthodes .insert(). Mais, avouons-le, écrire 10 lignes de code pour créer un dictionnaire de trois paires, c'est pénible. Heureusement, il existe des solutions.

Méthode n°1 : La classique — HashMap::new() + insert()

Commençons par les bases. C'est la méthode la plus compréhensible et transparente. Vous créez un HashMap vide et vous le remplissez :

use std::collections::HashMap;\n\nfn main() {\n    let mut scores = HashMap::new();\n    scores.insert("Alice".to_string(), 42);\n    scores.insert("Bob".to_string(), 27);\n    scores.insert("Charlie".to_string(), 35);\n\n    println!("{:?}", scores);\n}

Avantages :

\n
• Contrôle total du processus.
\n
• Possibilité d'ajouter des éléments conditionnellement.
\n
• Aucune dépendance supplémentaire requise.
\n

Inconvénients :

\n <>Verbeux.\n
• Nécessite mut.
\n
• Ne convient pas aux constantes.
\n

Cette méthode est bonne pour un remplissage dynamique, mais pour des données statiques, elle est excessive.

Méthode n°2 : from() — quand les données sont déjà prêtes

Si vous avez un vecteur de tuples, vous pouvez utiliser HashMap::from() :

use std::collections::HashMap;\n\nfn main() {\n    let data = vec![\n        ("Alice", 42),\n        ("Bob", 27),\n        ("Charlie", 35),\n    ];\n\n    let scores: HashMap<&str, i32> = HashMap::from(data);\n    println!("{:?}", scores);\n}

C'est déjà plus proche d'un "littéral". Cela semble plus propre, mais nécessite toujours un vecteur intermédiaire. C'est rapide, mais pour de grands ensembles de données, cela peut être inefficace en raison d'une double allocation mémoire.

Méthode n°3 : collect() — l'approche fonctionnelle

Les fans d'itérateurs apprécieront cette méthode :

use std::collections::HashMap;\n\nfn main() {\n    let scores: HashMap<&str, i32> = [\n        ("Alice", 42),\n        ("Bob", 27),\n        ("Charlie", 35),\n    ].iter().cloned().collect();\n\n    println!("{:?}", scores);\n}

Beau ? Oui. Lisible ? À la limite. Mais c'est l'une des méthodes les plus idiomatiques en Rust. .iter().cloned().collect() est un motif standard pour convertir un tableau en collection.

D'ailleurs, si vos clés et valeurs implémentent Copy, vous pouvez utiliser .copied() au lieu de .cloned() — c'est un peu plus rapide.

Méthode n°4 : La macro hashmap! — le salut de 2025

Et voici