Learn Rust Coding · Lekcja

use i ścieżki

Importowanie elementów

use i ścieżki to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Wprowadzanie elementów do zakresu

Wpisywanie pełnych ścieżek, takich jak std::collections::HashMap, w każdym miejscu jest uciążliwe. Słowo kluczowe use wprowadza element do zakresu, dzięki czemu można odwoływać się do niego za pomocą krótkiej nazwy.

Podstawowe użycie use

Po użyciu use odwołuje się Pan/Pani do elementu za pomocą jego końcowej nazwy. Tutaj importujemy HashMap i używamy go bezpośrednio.

use std::collections::HashMap;

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

Ścieżki bezwzględne a względne

Ścieżka bezwzględna zaczyna się od crate (korzenia crate). Ścieżka względna zaczyna się od bieżącego modułu i może opcjonalnie używać self lub 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 wewnątrz modułów

Instrukcja use wpływa tylko na zakres, w którym się znajduje. Umieść ją na początku modułu, aby skrócić nazwy używane w całym tym 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();
}

Zmiana nazwy za pomocą as

Gdy dwa elementy mają tę samą nazwę albo nazwa jest zbyt długa, można zmienić ją podczas importowania za pomocą 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"));
}

Grupowanie importów

Można zaimportować kilka elementów z tej samej ścieżki w jednym wierszu, używając nawiasów klamrowych. Dzięki temu blok importów pozostaje uporządkowany.

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());
}

Zagnieżdżone grupy i self

W grupie self importuje sam moduł wraz z jego elementami. Dzięki temu można używać zarówno nazwy modułu, jak i konkretnych składowych.

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

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

Importy typu glob

Glob * importuje wszystko, co publiczne, z danej ścieżki. Używaj go oszczędnie — może ukrywać źródło nazw — ale jest często stosowany w prelude i testach.

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

use colors::*;

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

Idiomatyczny styl importów

Konwencja: importuj funkcje przez ich moduł nadrzędny (use std::cmp; cmp::max(...)), ale typy importuj po nazwie (use std::collections::HashMap;). Dzięki temu wywołania są czytelniejsze.

use std::cmp;

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

Ścieżki do zewnętrznych crate

W przypadku zależności ścieżka zaczyna się od nazwy crate, na przykład rand::thread_rng. Crate należy dodać w Cargo.toml, a następnie importować elementy tak samo jak w przypadku std.

Porządkowanie importów

Grupuj powiązane importy, zmieniaj nazwy, aby uniknąć konfliktów, i w kodzie aplikacji preferuj jawne importy zamiast globów. Uporządkowane importy ułatwiają szybkie przejrzenie pliku.

Szybkie sprawdzenie

Sprawdź swoją znajomość ścieżek.

Powtórzenie

Nauczył(a) się Pan/Pani importować elementy:

use wprowadza element do zakresu pod krótką nazwą
Ścieżki bezwzględne zaczynają się od crate, a względne używają self/super
as zmienia nazwy, nawiasy klamrowe grupują elementy, a * importuje globem
Dla czytelności typy należy importować po nazwie, a funkcje przez moduł nadrzędny

Często zadawane pytania

Czy lekcja „use i ścieżki” jest bezpłatna?

Tak — pełny tekst „use i ścieżki” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „use i ścieżki”?

Importowanie elementów Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „use i ścieżki”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding