Learn Rust Coding · Lekcja

Klauzule where i wiele ograniczeń

Zachowa Pan/Pani czytelność złożonych sygnatur.

Klauzule where i wiele ograniczeń to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 4 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.

Gdy ograniczenia w deklaracji stają się nieczytelne

Ograniczenia zapisane bezpośrednio, takie jak <T: Display + Clone, U: Debug + Default>, stają się trudne do odczytania, gdy ich przybywa. Rust oferuje klauzulę where jako czytelniejszą alternatywę.

Przenosi ona ograniczenia pod sygnaturę, dzięki czemu lista parametrów pozostaje krótka.

Podstawowa klauzula where

Klauzula where znajduje się między typem zwracanym a ciałem funkcji. Każdy wiersz zawiera typ i jego ograniczenia.

Te dwie sygnatury oznaczają dokładnie to samo; forma z where jest po prostu czytelniejsza.

use std::fmt::Display;

fn show<T>(value: T)
where
    T: Display,
{
    println!("{}", value);
}

Wiele ograniczeń w where

Można umieścić kilka ograniczeń — po jednym dla każdego parametru typu — oddzielonych przecinkami. Każdy parametr może łączyć cechy za pomocą +.

Dzięki temu złożona sygnatura pozostaje czytelna, zamiast zawierać wszystkie ograniczenia w jednym miejscu.

use std::fmt::{Display, Debug};

fn report<T, U>(a: T, b: U)
where
    T: Display + Clone,
    U: Debug,
{
    println!("{} {:?}", a, b);
}

Kompletny przykład

Ten program używa klauzuli where wymagającej cechy Display. Uruchamia się i wypisuje każdy argument wraz z etykietą.

Zwróć uwagę, że nagłówek funkcji pozostaje przejrzysty, mimo dołączonego ograniczenia.

use std::fmt::Display;

fn label<T>(name: &str, value: T)
where
    T: Display,
{
    println!("{} = {}", name, value);
}

fn main() {
    label("age", 30);
    label("city", "Oslo");
}

Ograniczenia, których kompilator nie może zapisać bezpośrednio

Niektóre ograniczenia można zapisać wyłącznie w klauzuli where, na przykład ograniczenia dotyczące typów powiązanych lub typów wskazywanych. Składnia bezpośrednia nie pozwala wyrazić where Vec<T>: Clone.

Forma where jest więc zdecydowanie bardziej wyrazista.

fn duplicate<T>(items: Vec<T>) -> (Vec<T>, Vec<T>)
where
    Vec<T>: Clone,
{
    (items.clone(), items)
}

Łączenie standardowych cech

Typowe ograniczenie spotykane w praktyce łączy porządkowanie, kopiowanie i wypisywanie. Ta funkcja generyczna max_of znajduje największy element w wycinku.

Klauzula where grupuje wszystkie trzy cechy, na których opiera się algorytm.

use std::fmt::Display;

fn max_of<T>(items: &[T]) -> &T
where
    T: PartialOrd + Display,
{
    let mut best = &items[0];
    for item in items {
        if item > best { best = item; }
    }
    best
}

Uruchamianie max_of

Oto ten sam pomysł w programie, który można uruchomić. Wycinek liczb całkowitych spełnia PartialOrd + Display, więc wywołanie się kompiluje i wypisuje maksimum.

Funkcja działałaby równie dobrze dla liczb zmiennoprzecinkowych lub znaków.

fn max_of<T>(items: &[T]) -> &T
where
    T: PartialOrd,
{
    let mut best = &items[0];
    for item in items {
        if item > best { best = item; }
    }
    best
}

fn main() {
    let nums = [3, 7, 1, 9, 4];
    println!("{}", max_of(&nums));
}

where w blokach impl

Klauzule where można również dołączać do bloków impl. Dzięki temu metoda jest dodawana tylko wtedy, gdy przechowywany typ implementuje Display.

Wystąpienia, których T nie implementuje Display, po prostu nie będą miały tej metody.

use std::fmt::Display;

struct Holder<T> { item: T }

impl<T> Holder<T>
where
    T: Display,
{
    fn print(&self) {
        println!("{}", self.item);
    }
}

Wiele ograniczeń jednocześnie

Rzeczywiste interfejsy generyczne często wymagają kilku cech dla każdego parametru. Ta sygnatura wymaga klonowania, debugowania i wartości domyślnej.

Klauzula where zachowuje czytelność mimo trzech ograniczeń dla jednego typu.

use std::fmt::Debug;

fn build<T>() -> T
where
    T: Default + Clone + Debug,
{
    let v = T::default();
    v.clone()
}

Wybór między zapisem bezpośrednim a where

Ograniczeń zapisanych bezpośrednio należy używać przy jednym lub dwóch prostych warunkach. Na where warto przejść, gdy występuje wiele parametrów, długie listy cech lub ograniczenia dotyczące złożonych typów.

Obie formy kompilują się do identycznego kodu; wybór dotyczy wyłącznie czytelności.

where z czasami życia

Klauzula where może zawierać zależności między czasami życia obok ograniczeń cech. Pomaga to uporządkować sygnatury generyczne zawierające oba rodzaje ograniczeń.

W tym przypadku klauzula wymaga, aby T żył co najmniej tak długo jak czas życia 'a.

fn keep<'a, T>(value: &'a T) -> &'a T
where
    T: 'a,
{
    value
}

Szybkie sprawdzenie

Sprawdź, czy rozumiesz klauzule where i wiele ograniczeń.

Podsumowanie

Klauzula where przenosi ograniczenia cech pod sygnaturę, poprawiając czytelność, gdy przybywa parametrów lub cech. Może również wyrażać ograniczenia dotyczące złożonych typów i czasów życia, których nie da się zapisać bezpośrednio.

Ograniczenia zapisane bezpośrednio i za pomocą where kompilują się identycznie, dlatego należy wybrać formę czytelniejszą.

Często zadawane pytania

Czy lekcja „Klauzule where i wiele ograniczeń” jest bezpłatna?

Tak — pełny tekst „Klauzule where i wiele ograniczeń” 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 „Klauzule where i wiele ograniczeń”?

Zachowa Pan/Pani czytelność złożonych sygnatur. Ć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 4 z 4.

Ile czasu zajmuje lekcja „Klauzule where i wiele ograniczeń”?

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