Deref und ergonomische Wrapper
Lassen Sie Wrapper sich wie native Typen anfühlen.
Deref und ergonomische Wrapper 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.
Das Problem der Ergonomie
Das Wrapping eines Typs erhöht die Sicherheit, verringert aber den Komfort: Plötzlich müssen Sie überall wrapper.0.method() schreiben und Methoden von Hand neu implementieren.
Das Trait Deref kann einen großen Teil dieser Ergonomie wiederherstellen, indem der Wrapper sich wie der von ihm gehaltene Wert verhält.
Was Deref bewirkt
Deref legt fest, was *value erzeugt, und ermöglicht den Operator .. Wenn Sie eine Methode aufrufen, die dem Wrapper fehlt, versucht der Compiler den Aufruf erneut am Deref-Ziel.
Dieser automatische Schritt wird Deref-Koersion genannt.
use std::ops::Deref;
struct MyBox<T>(T);
impl<T> Deref for MyBox<T> {
type Target = T;
fn deref(&self) -> &T { &self.0 }
}Deref-Koersion in Aktion
Sobald Deref implementiert ist, funktionieren Aufrufe innerer Methoden auf dem Wrapper einfach. Der Compiler fügt für Sie .deref() ein, bis die Methode gefunden wird.
use std::ops::Deref;
struct Name(String);
impl Deref for Name {
type Target = String;
fn deref(&self) -> &String { &self.0 }
}
fn main() {
let n = Name("rustacean".to_string());
println!("len = {}", n.len()); // String::len via deref
}DerefMut für veränderbaren Zugriff
Deref ermöglicht nur gemeinsamen Zugriff. Um über den Wrapper Methoden aufzurufen, die &mut self benötigen, implementieren Sie zusätzlich DerefMut, das eine veränderbare Referenz auf den inneren Wert zurückgibt.
use std::ops::{Deref, DerefMut};
struct Stack(Vec<i32>);
impl Deref for Stack {
type Target = Vec<i32>;
fn deref(&self) -> &Vec<i32> { &self.0 }
}
impl DerefMut for Stack {
fn deref_mut(&mut self) -> &mut Vec<i32> { &mut self.0 }
}Koersion an Funktionsgrenzen
Deref-Koersion gilt auch für Argumente. Ein &Name wird zu &String koerziert, das seinerseits zu &str koerziert wird. Daher können Sie den Wrapper direkt an Funktionen übergeben, die die innere Referenz erwarten.
fn greet(who: &str) {
println!("hi {}", who);
}
// greet(&name) works: &Name -> &String -> &strEin ausführbares Beispiel für Koersion
Dieses Programm übergibt eine Wrapper-Referenz, wo ein String-Slice erwartet wird. Die verketteten Deref-Koersionen erfolgen am Aufrufort stillschweigend.
use std::ops::Deref;
struct Tag(String);
impl Deref for Tag {
type Target = String;
fn deref(&self) -> &String { &self.0 }
}
fn shout(s: &str) { println!("{}!", s.to_uppercase()); }
fn main() {
let t = Tag("ship".to_string());
shout(&t);
}Deref nicht missbrauchen
Die Rust-API-Richtlinien warnen davor, Deref für Typen zu implementieren, die keine echten Smart Pointer sind. Eine übermäßige Verwendung macht die verfügbaren Methoden des Wrappers unvorhersehbar und überrascht die Lesenden.
Wenn der Newtype dazu dient, eine API einzuschränken, kann ein uneingeschränktes Deref genau die Methoden nach außen geben, die Sie eigentlich verbergen wollten.
AsRef als gezielte Alternative
Wenn Sie nur eine explizite Konvertierung statt einer automatischen Koersion benötigen, implementieren Sie AsRef. Aufrufende schreiben bewusst .as_ref(), wodurch die eigene Oberfläche des Wrappers klar bleibt.
struct Path(String);
impl AsRef<str> for Path {
fn as_ref(&self) -> &str { &self.0 }
}Ausgewählte Methoden weiterleiten
Bei einem einschränkenden Wrapper sollten Sie nur die gewünschten Methoden von Hand schreiben. So behalten Sie die vollständige Kontrolle über die API, statt über Deref alles nach außen zu geben.
struct Counter(Vec<u8>);
impl Counter {
fn len(&self) -> usize { self.0.len() }
fn push(&mut self, b: u8) { self.0.push(b); }
}Smart Pointer verwenden Deref
Standard-Smart-Pointer wie Box, Rc und Arc implementieren alle Deref. Deshalb können Sie ihre inneren Methoden transparent aufrufen. Dies ist die legitime und vorgesehene Verwendung des Traits.
use std::rc::Rc;
fn main() {
let shared = Rc::new(String::from("data"));
// Deref lets us call String methods directly
println!("len = {}", shared.len());
}Ihre Strategie für Ergonomie wählen
Richten Sie Ihre Wahl nach dem Zweck. Verwenden Sie Deref für echte Smart-Pointer-Wrapper, AsRef für explizite Konvertierungen geliehener Werte und manuelle Weiterleitung, wenn ein Newtype die API seines inneren Typs einschränken muss.
Die falsche Wahl verbirgt entweder zu viel oder gibt zu viel preis.
Kurze Überprüfung
Entscheiden Sie, welcher Wrapper eine Deref-Implementierung verdient.
Zusammenfassung
Deref und Deref-Koersion stellen die Ergonomie von Wrappern wieder her, indem der Operator . und Referenzargumente auf den inneren Wert durchgereicht werden; DerefMut fügt veränderbaren Zugriff hinzu.
Verwenden Sie Deref nur für echte Smart Pointer. Bei einschränkenden Newtypes verwenden Sie AsRef für explizite Konvertierungen oder leiten nur die Methoden weiter, die Sie bereitstellen möchten.
Lerne Rust mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 39
- Lektionen
- 144
Häufig gestellte Fragen
Ist die Lektion „Deref und ergonomische Wrapper“ kostenlos?
Ja — der vollständige Text von „Deref und ergonomische Wrapper“ 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 „Deref und ergonomische Wrapper“?
Lassen Sie Wrapper sich wie native Typen anfühlen. 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 „Deref und ergonomische Wrapper“?
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
- Das Builder-Pattern
- Das Newtype-Pattern
- Builder mit Type-State
- Deref und ergonomische Wrapper