Learn Rust Coding · Leçon

use et chemins

Importer des éléments

use et chemins est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 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.

Importer des éléments dans la portée

Écrire partout des chemins complets comme std::collections::HashMap est fastidieux. Le mot-clé use introduit un élément dans la portée, afin que vous puissiez le désigner par un nom court.

Un use de base

Après un use, vous référencez l’élément par son nom final. Ici, nous importons HashMap et l’utilisons directement.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("ana", 10);
    println!("{:?}", scores.get("ana"));
}

Chemins absolus et relatifs

Un chemin absolu commence par crate (la racine de la caisse). Un chemin relatif commence dans le module actuel et peut utiliser self ou super.

mod a {
    pub mod b {
        pub fn hi() { println!("hi from b"); }
    }
    pub fn call_b() {
        crate::a::b::hi();
        self::b::hi();
    }
}

fn main() {
    a::call_b();
}

use dans les modules

Un use n’agit que dans la portée où il apparaît. Placez-le au début d’un module pour raccourcir les noms utilisés dans ce module.

mod work {
    use std::collections::HashSet;
    pub fn run() {
        let mut s = HashSet::new();
        s.insert(1);
        s.insert(1);
        println!("size {}", s.len());
    }
}

fn main() {
    work::run();
}

Renommer avec as

Lorsque deux éléments portent le même nom ou qu’un nom est trop long, renommez-le lors de l’importation avec as.

use std::collections::HashMap as Map;

fn main() {
    let mut m: Map<&str, i32> = Map::new();
    m.insert("x", 1);
    println!("{:?}", m.get("x"));
}

Regrouper les importations

Importez plusieurs éléments du même chemin sur une seule ligne en utilisant des accolades. Le bloc d’importation reste ainsi bien organisé.

use std::collections::{HashMap, HashSet};

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

Groupes imbriqués et self

À l’intérieur d’un groupe, self importe le module lui-même avec ses éléments. Vous pouvez ainsi utiliser à la fois le nom du module et des membres précis.

use std::io::{self, Write};

fn main() {
    let _ = io::stdout().write_all(b"hello\n");
}

Importations glob

Le glob * importe tout ce qui est public depuis un chemin. Utilisez-le avec parcimonie — il peut masquer l’origine des noms — mais il est courant dans les préludes et les tests.

mod colors {
    pub fn red() -> &'static str { "red" }
    pub fn blue() -> &'static str { "blue" }
}

use colors::*;

fn main() {
    println!("{} {}", red(), blue());
}

Style d’importation idiomatique

Convention : importez les fonctions via leur module parent (use std::cmp; cmp::max(...)), mais importez les types par leur nom (use std::collections::HashMap;). Les appels sont ainsi plus clairs à lire.

use std::cmp;

fn main() {
    println!("{}", cmp::max(3, 9));
}

Chemins vers les crates externes

Pour les dépendances, le chemin commence par le nom de la crate, par exemple rand::thread_rng. Vous indiquez la crate dans Cargo.toml, puis vous importez ses éléments comme vous le faites pour std.

Garder des importations propres

Regroupez les importations associées, renommez-les pour éviter les conflits et préférez les importations explicites aux globs dans le code applicatif. Des importations propres rendent un fichier facile à parcourir.

Vérification rapide

Testez vos connaissances des chemins.

Récapitulatif

Vous avez appris à importer des éléments :

use introduit un élément dans la portée sous un nom court
Les chemins absolus commencent à crate ; les chemins relatifs utilisent self/super
as renomme, les accolades regroupent et * utilise un glob
Importez les types par leur nom et les fonctions via leur module parent pour plus de clarté

Questions Fréquemment Posées

La leçon « use et chemins » est-elle gratuite ?

Oui — le texte complet de « use et chemins » 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 « use et chemins » ?

Importer des éléments 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 3 sur 4.

Combien de temps prend la leçon « use et chemins » ?

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