0Pricing
Learn Rust Coding · Lektion

Traits definieren und implementieren

Beherrschen Sie Traits, um gemeinsames Verhalten für verschiedene Typen zu definieren, ähnlich wie Interfaces in anderen Sprachen.

Traits definieren und implementieren ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. 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 3 Lektionen.

Was sind Traits in Rust?

In Rust bieten Traits eine leistungsfähige Möglichkeit, gemeinsames Verhalten für verschiedene Typen zu definieren. Stellen Sie sie sich wie Schnittstellen in anderen Sprachen vor.

Ein Trait teilt Rust mit, dass ein bestimmter Typ bestimmte Funktionen besitzt. Wenn ein Typ ein Trait implementiert, bedeutet das, dass dieser Typ die im Trait definierten Methoden bereitstellt.

  • Traits ermöglichen Polymorphie: Sie können mit verschiedenen Typen auf einheitliche Weise arbeiten.
  • Sie sind ein wesentlicher Bestandteil des Typsystems und der sicheren Abstraktionen von Rust.

Ihr erstes Trait deklarieren

Sie definieren ein Trait mit dem Schlüsselwort trait. Darin listen Sie Methodensignaturen (Namen, Parameter und Rückgabetypen) auf, die jeder implementierende Typ bereitstellen muss.

Definieren wir ein einfaches Trait Summary für Elemente, die zusammengefasst werden können.

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

fn main() {
  // Traits are definitions, not directly executable.
  // We will implement and use them in later scenes!
  println!("Trait 'Summary' defined.");
}

Traits für Typen implementieren

Damit ein Typ ein Trait verwendet, nutzen Sie die Syntax impl Trait for Type. Anschließend stellen Sie für jede im Trait definierte Methode eine konkrete Implementierung bereit.

Hier implementieren wir Summary für ein Struct NewsArticle.

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

struct NewsArticle {
  headline: String,
  location: String,
  author: String,
  content: String,
}

impl Summary for NewsArticle {
  fn summarize(&self) -> String {
    format!("{}, by {} ({})", self.headline, self.author, self.location)
  }
}

fn main() {
  let article = NewsArticle {
    headline: String::from("Penguins win Stanley Cup!"),
    location: String::from("Pittsburgh, PA"),
    author: String::from("Iceburgh"),
    content: String::from("The Pittsburgh Penguins have won..."),
  };

  println!("New article summary: {}", article.summarize());
}

Funktionen mit Trait Bounds verwenden

Sobald ein Typ ein Trait implementiert, können Sie Funktionen schreiben, die jeden Typ akzeptieren, der dieses Trait implementiert. Das ermöglicht flexiblen und generischen Code.

Die Funktion notify kann jeden Typ akzeptieren, der Summary implementiert.

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

struct NewsArticle {
  headline: String,
  location: String,
  author: String,
  content: String,
}

impl Summary for NewsArticle {
  fn summarize(&self) -> String {
    format!("{}, by {} ({})", self.headline, self.author, self.location)
  }
}

struct Tweet {
  username: String,
  content: String,
  reply: bool,
  retweet: bool,
}

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

fn notify(item: &impl Summary) { // impl Summary is syntax sugar for a trait bound
  println!("Breaking news! {}", item.summarize());
}

fn main() {
  let tweet = Tweet {
    username: String::from("horse_ebooks"),
    content: String::from("of course, as you probably already know, people"),
    reply: false,
    retweet: false,
  };

  let article = NewsArticle {
    headline: String::from("Rust is awesome!"),
    location: String::from("Internet"),
    author: String::from("Rustacean"),
    content: String::from("Rust's type system is amazing."),
  };

  notify(&tweet);
  notify(&article);
}

Traits mit Standardverhalten

Traits können für ihre Methoden auch Standardimplementierungen bereitstellen. Das bedeutet, dass Typen nicht jede Methode implementieren müssen, wenn eine Standardimplementierung vorhanden ist.

Sie können die Standardimplementierung verwenden oder sie mit einer eigenen Logik überschreiben.

trait Summary {
  fn summarize_author(&self) -> String; // New required method
  fn summarize(&self) -> String { // Default implementation
    format!("(Read more from {})", self.summarize_author())
  }
}

struct Tweet {
  username: String,
  content: String,
  reply: bool,
  retweet: bool,
}

impl Summary for Tweet {
  fn summarize_author(&self) -> String { // Must implement required method
    format!("@{}", self.username)
  }
  // We are using the default summarize() method here!
}

fn main() {
  let tweet = Tweet {
    username: String::from("dog_lover"),
    content: String::from("My dog is the best!"),
    reply: false,
    retweet: false,
  };

  println!("Tweet summary: {}", tweet.summarize());
}

Generische Funktionen mit Traits

Beim Schreiben generischer Funktionen oder Structs können Sie Trait Bounds verwenden, um festzulegen, dass ein generischer Typparameter T ein bestimmtes Trait implementieren muss.

Dadurch wird sichergestellt, dass die Methoden dieses Traits für T verfügbar sind.

trait Displayable {
  fn display(&self);
}

struct Point<T> {
  x: T,
  y: T,
}

// Implement Displayable for Point<i32>
impl Displayable for Point<i32> {
  fn display(&self) {
    println!("Point: ({}, {})", self.x, self.y);
  }
}

// Generic function that works for any type T that implements Displayable
fn print_item<T: Displayable>(item: T) {
  item.display();
}

fn main() {
  let p = Point { x: 10, y: 20 };
  print_item(p);
  // This function only works for types that implement Displayable
  // let s = String::from("Hello");
  // print_item(s); // This would cause a compile-time error
}

Mehrere Trait Bounds kombinieren

Manchmal muss ein generischer Typ mehr als ein Trait implementieren. Sie können mehrere Trait Bounds mit dem Operator + angeben.

In komplexeren Situationen, insbesondere bei vielen generischen Parametern, kann die where-Klausel die Lesbarkeit verbessern.

use std::fmt::Debug;

trait Printable {
  fn print_info(&self);
}

struct Book {
  title: String,
  pages: u32,
}

impl Printable for Book {
  fn print_info(&self) {
    println!("Book: '{}' ({} pages)", self.title, self.pages);
  }
}

impl Debug for Book { // Book also implements Debug trait
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "Book {{ title: {}, pages: {} }}", self.title, self.pages)
  }
}

// A function that requires its argument to be both Printable and Debug
fn process_item<T: Printable + Debug>(item: T) {
  item.print_info();
  println!("Debug info: {:?}", item);
}

fn main() {
  let my_book = Book {
    title: String::from("The Rust Book"),
    pages: 600,
  };

  process_item(my_book);
}

Typen mit `impl Trait` zurückgeben

Die Syntax impl Trait ist nicht nur für Funktionsparameter gedacht, sondern kann auch an Rückgabepositionen verwendet werden. Das ist nützlich, wenn Sie einen Typ zurückgeben möchten, der ein bestimmtes Trait implementiert, dessen konkreten Typ Sie aber nicht offenlegen möchten.

Dadurch werden Funktionssignaturen einfacher und Ihre API bleibt flexibel.

trait Greeter {
  fn greet(&self) -> String;
}

struct FriendlyGreeter;
impl Greeter for FriendlyGreeter {
  fn greet(&self) -> String {
    String::from("Hello there!")
  }
}

struct FormalGreeter;
impl Greeter for FormalGreeter {
  fn greet(&self) -> String {
    String::from("Greetings and salutations.")
  }
}

// This function returns *some* type that implements Greeter
// The caller doesn't need to know if it's FriendlyGreeter or FormalGreeter
fn get_greeter(formal: bool) -> impl Greeter {
  if formal {
    FormalGreeter
  } else {
    FriendlyGreeter
  }
}

fn main() {
  let casual_greet = get_greeter(false);
  println!("{}", casual_greet.greet());

  let formal_greet = get_greeter(true);
  println!("{}", formal_greet.greet());
}

Aufbauend auf Supertraits

Manchmal hängt ein Trait logisch von einem anderen ab. Rust ermöglicht es Ihnen, Supertraits zu definieren. Das bedeutet, dass ein Trait verlangen kann, dass jeder Typ, der ihn implementiert, auch ein bestimmtes anderes Trait implementiert.

Dies geschieht mit der Syntax trait SubTrait: SuperTrait. Es ist, als würde man sagen: „Wenn Sie X können, müssen Sie auch Y können.“

trait Printable {
  fn print_content(&self);
}

// Debug is a supertrait of PrintableDebug
// Any type implementing PrintableDebug must also implement Debug
trait PrintableDebug: Printable + std::fmt::Debug {
  fn print_debug_and_content(&self) {
    self.print_content();
    println!("Debug info: {:?}", self);
  }
}

struct Item {
  id: u32,
  name: String,
}

impl Printable for Item {
  fn print_content(&self) {
    println!("Item ID: {}, Name: {}", self.id, self.name);
  }
}

impl std::fmt::Debug for Item {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "Item {{ id: {}, name: {} }}", self.id, self.name)
  }
}

// Now we can implement PrintableDebug because Item implements both Printable and Debug
impl PrintableDebug for Item {}

fn main() {
  let my_item = Item {
    id: 101,
    name: String::from("Widget A"),
  };
  my_item.print_debug_and_content();
}

Testen Sie Ihr Trait-Wissen

Betrachten Sie das folgende Rust-Codefragment. Welche der folgenden Aussagen über Traits und Trait-Bounds ist WAHR?

Traits: Ihr Werkzeugkasten für Verhalten

Wir haben das leistungsstarke Trait-System von Rust kennengelernt!

  • Traits definieren eine Gruppe von Methoden, die ein Typ implementieren kann, und fungieren damit ähnlich wie Schnittstellen.
  • Sie implementieren Traits für bestimmte Typen mit impl Trait for Type.
  • Trait-Bounds (T: Trait) ermöglichen es generischen Funktionen und Strukturen, mit jedem Typ zu arbeiten, der ein erforderliches Trait implementiert.
  • Traits können Standardimplementierungen enthalten. Außerdem können Sie mehrere Trait-Bounds (T: Trait1 + Trait2) oder Supertraits verwenden.
  • impl Trait kann auch an Rückgabepositionen verwendet werden, um konkrete Typen zu verbergen.

Traits sind grundlegend für flexiblen, wiederverwendbaren und sicheren Rust-Code!

Häufig gestellte Fragen

Ist die Lektion „Traits definieren und implementieren“ kostenlos?

Ja — der vollständige Text von „Traits definieren und implementieren“ 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 3 Lektionen.

Was lerne ich in „Traits definieren und implementieren“?

Beherrschen Sie Traits, um gemeinsames Verhalten für verschiedene Typen zu definieren, ähnlich wie Interfaces in anderen Sprachen. 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 2 von 3.

Wie lange dauert die Lektion „Traits definieren und implementieren“?

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. Generischen Code in Rust schreiben
  2. Traits definieren und implementieren
  3. Fortgeschrittene Trait-Nutzung: Associated Types
← Zurück zu Learn Rust Coding