Learn Rust Coding · Lekcja

Ograniczenia traitów

Ograniczy Pan/Pani generyki za pomocą traitów.

Ograniczenia traitów 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.

Działanie ograniczeń cech

Ograniczenie cechy zawęża typ generyczny do typów implementujących daną cechę. Informuje kompilator, jakie zachowanie gwarantuje ten typ.

Odblokowuje to metody cechy wewnątrz kodu generycznego, a jednocześnie pozwala używać funkcji z wieloma typami.

Składnia ograniczenia w miejscu deklaracji

Najprostsza forma umieszcza ograniczenie bezpośrednio po parametrze typu: T: Trait. W tym przypadku T musi implementować Display, aby można było go wyświetlić.

Wewnątrz funkcji można teraz wywoływać dowolną metodę udostępnianą przez Display.

use std::fmt::Display;

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

Własna cecha

Ograniczenia działają także z własnymi cechami. Zdefiniuj cechę z metodą, a następnie ogranicz nią funkcję generyczną.

Cecha Summary wymaga metody summarize zwracającej łańcuch znaków.

trait Summary {
    fn summarize(&self) -> String;
}

Implementowanie i ograniczanie

Zaimplementuj cechę dla typu, a następnie funkcja z ograniczeniem będzie mogła przyjąć dowolny typ, który ją implementuje. Funkcja wywołuje metodę cechy bez znajomości konkretnego typu.

Ten kompletny program wyświetla podsumowanie obiektu Article.

trait Summary { fn summarize(&self) -> String; }

struct Article { title: String }

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("Article: {}", self.title)
    }
}

fn notify<T: Summary>(item: &T) {
    println!("{}", item.summarize());
}

fn main() {
    let a = Article { title: String::from("Rust") };
    notify(&a);
}

Łączenie ograniczeń za pomocą +

Wymagaj kilku cech jednocześnie, łącząc je za pomocą +. W tym przypadku T musi implementować zarówno Display, jak i Clone.

Funkcja może wtedy wyświetlić wartość, a także utworzyć jej klon.

use std::fmt::Display;

fn process<T: Display + Clone>(value: T) {
    let copy = value.clone();
    println!("{}", copy);
}

Cecha impl w argumentach

Składnia impl Trait użyta w pozycji argumentu jest skróconym zapisem prostego ograniczenia. item: &impl Summary oznacza to samo co parametr <T: Summary>.

Jest zwięzła w przypadku funkcji z jednym argumentem, ale zapewnia mniejszą kontrolę, gdy typ jest używany ponownie.

trait Summary { fn summarize(&self) -> String; }

fn notify(item: &impl Summary) {
    println!("{}", item.summarize());
}

Zwracanie impl Trait

Można również zwracać impl Trait, ukrywając konkretny typ i jednocześnie gwarantując, że implementuje on daną cechę. Jest to przydatne w przypadku domknięć i iteratorów.

Wywołujący wie tylko, że wynik implementuje wskazaną cechę.

fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n
}

fn main() {
    let add5 = make_adder(5);
    println!("{}", add5(10));
}

Ograniczenia umożliwiają używanie operatorów

Operatory odpowiadają cechom: + wymaga Add, == wymaga PartialEq, a porównania wymagają PartialOrd. Ograniczenie za pomocą tych cech pozwala kodowi generycznemu używać operatorów.

W tym przypadku sumowanie wymaga, aby T implementował Add dla samego siebie.

use std::ops::Add;

fn sum<T: Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

Domyślne metody cech

Cechy mogą udostępniać domyślne implementacje metod. Implementujące je typy mogą je nadpisać albo korzystać z wartości domyślnych. Ograniczone typy generyczne używają tej implementacji, która obowiązuje.

Ta cecha Summary ma domyślną metodę summarize, którą typy mogą pozostawić bez zmian.

trait Summary {
    fn summarize(&self) -> String {
        String::from("(no summary)")
    }
}

struct Note;
impl Summary for Note {}

Dyspozycja statyczna a dynamiczna

Ograniczenia cech korzystają z dyspozycji statycznej: kompilator wybiera dokładną metodę w czasie kompilacji za pomocą monomorfizacji. Natomiast dyn Trait korzysta z dyspozycji dynamicznej za pośrednictwem vtable.

Ograniczenia są zwykle szybsze; dyn poświęca szybkość na rzecz mniejszych plików binarnych i elastyczności w czasie działania.

Ograniczenia w strukturach generycznych

Ograniczenia cech nie dotyczą wyłącznie funkcji. Można wymagać ich podczas definiowania struktury, aby wszystkie jej wystąpienia spełniały daną cechę.

W tym przypadku każdy obiekt Sortable<T> gwarantuje, że jego elementy można porównywać.

struct Sortable<T: PartialOrd> {
    items: Vec<T>,
}

Szybkie sprawdzenie

Sprawdź, czy rozumiesz ograniczenia cech.

Podsumowanie

Ograniczenia cech zawężają typy generyczne, dzięki czemu kompilator zezwala na używanie metod i operatorów danej cechy. Cechy można łączyć za pomocą +, a impl Trait stosować jako skrócony zapis w argumentach lub wartościach zwracanych.

Ograniczenia zapewniają dyspozycję statyczną bez dodatkowego narzutu, w przeciwieństwie do dyspozycji dynamicznej dyn Trait.

Często zadawane pytania

Czy lekcja „Ograniczenia traitów” jest bezpłatna?

Tak — pełny tekst „Ograniczenia traitów” 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 „Ograniczenia traitów”?

Ograniczy Pan/Pani generyki za pomocą traitó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 „Ograniczenia traitów”?

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