0Pricing
Learn Rust Coding · Lektion

where-Klauseln und mehrere Bounds

Halten Sie komplexe Signaturen lesbar.

where-Klauseln und mehrere Bounds ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Wenn Inline-Schranken unübersichtlich werden

Inline-Schranken wie <T: Display + Clone, U: Debug + Default> werden mit zunehmendem Umfang schwer lesbar. Rust bietet mit der where-Klausel eine übersichtlichere Alternative.

Sie verschiebt die Einschränkungen unter die Signatur und hält dadurch die Parameterliste kurz.

Einfache where-Klausel

Eine where-Klausel steht zwischen dem Rückgabetyp und dem Funktionskörper. Jede Zeile führt einen Typ und seine Schranken auf.

Diese beiden Signaturen bedeuten genau dasselbe; die Form mit where ist lediglich besser lesbar.

use std::fmt::Display;

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

Mehrere Schranken in where

Sie können mehrere Einschränkungen angeben, eine pro Typparameter, und sie durch Kommas trennen. Jede davon kann Traits mit + kombinieren.

So bleibt eine umfangreiche Signatur lesbar, statt alle Einschränkungen inline zusammenzupressen.

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

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

Ein vollständiges Beispiel

Dieses Programm verwendet eine where-Klausel, die Display voraussetzt. Es wird ausgeführt und gibt jedes Argument mit einer Bezeichnung aus.

Beachten Sie, dass der Funktionskopf trotz der angehängten Schranke übersichtlich bleibt.

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

Schranken, die der Compiler nicht inline darstellen kann

Einige Schranken können nur in einer where-Klausel geschrieben werden, etwa Schranken für zugehörige oder referenzierte Typen. Die Inline-Syntax kann where Vec<T>: Clone nicht ausdrücken.

Die where-Form ist daher ausdrucksstärker.

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

Standard-Traits kombinieren

Eine häufige Schranke aus der Praxis kombiniert Sortieren, Kopieren und Ausgeben. Dieses generische max_of findet das größte Element in einem Slice.

Die where-Klausel fasst alle drei Traits zusammen, auf die sich der Algorithmus stützt.

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
}

max_of ausführen

Hier sehen Sie dieselbe Idee in einem ausführbaren Programm. Der Slice mit Ganzzahlen erfüllt PartialOrd + Display, sodass der Aufruf kompiliert und das Maximum ausgibt.

Die Funktion würde ebenso mit Gleitkommazahlen oder Zeichen funktionieren.

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 bei impl-Blöcken

where-Klauseln können auch an impl-Blöcke angehängt werden. Dadurch wird eine Methode nur hinzugefügt, wenn der gespeicherte Typ Display implementiert.

Instanzen, deren T nicht Display ist, besitzen diese Methode einfach nicht.

use std::fmt::Display;

struct Holder<T> { item: T }

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

Viele Schranken auf einmal

Generische APIs aus der Praxis erfordern oft mehrere Traits pro Parameter. Diese Signatur verlangt Klonen, Debug-Ausgabe und einen Standardwert.

Die where-Klausel hält die Signatur trotz drei Schranken für einen Typ lesbar.

use std::fmt::Debug;

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

Inline oder where wählen

Verwenden Sie Inline-Schranken für ein oder zwei einfache Einschränkungen. Wechseln Sie zu where, wenn es viele Parameter, lange Trait-Listen oder Schranken für komplexe Typen gibt.

Beide Formen werden in identischen Code kompiliert; die Wahl betrifft ausschließlich die Lesbarkeit.

where mit Lebensdauern

Eine where-Klausel kann neben Trait-Schranken auch Beziehungen zwischen Lebensdauern aufführen. So bleiben generische Signaturen mit beiden Arten von Einschränkungen übersichtlich.

Hier verlangt die Klausel, dass T die Lebensdauer 'a überlebt.

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

Kurze Überprüfung

Testen Sie Ihr Verständnis von where-Klauseln und mehreren Schranken.

Zusammenfassung

Eine where-Klausel verschiebt Trait-Schranken unter die Signatur und verbessert die Lesbarkeit, wenn Parameter oder Trait-Listen umfangreicher werden. Außerdem kann sie Schranken für komplexe Typen und Lebensdauern ausdrücken, die mit der Inline-Syntax nicht möglich sind.

Inline-Schranken und where-Schranken werden identisch kompiliert. Wählen Sie daher die Form, die besser lesbar ist.

Häufig gestellte Fragen

Ist die Lektion „where-Klauseln und mehrere Bounds“ kostenlos?

Ja — der vollständige Text von „where-Klauseln und mehrere Bounds“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „where-Klauseln und mehrere Bounds“?

Halten Sie komplexe Signaturen lesbar. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „where-Klauseln und mehrere Bounds“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Generische Funktionen
  2. Generische Structs und Enums
  3. Trait-Bounds
  4. where-Klauseln und mehrere Bounds
← Zurück zu Learn Rust Coding