Vektoren aus Structs
Speichern Sie komplexe Daten in einem Vec.
Vektoren aus Structs 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.
Warum Vektoren aus Structs?
Vektoren können jeden einzelnen Typ enthalten, auch Ihre eigenen Structs. Ein Vec<Person> speichert mehrere Personen in einer bestimmten Reihenfolge und eignet sich daher hervorragend für Listen von Datensätzen wie Benutzern, Artikeln oder Punktzahlen.
So verbinden Sie eigene Datenstrukturen mit einer dynamisch wachsenden Liste.
Ein Struct definieren
Definieren Sie zuerst das Struct, das Sie speichern möchten. Dieses Person-Struct enthält einen Namen und ein Alter.
Die Zeile #[derive(Debug)] ermöglicht es, eine Person mit {:?} auszugeben, was für ganze Vektoren nützlich ist.
#[derive(Debug)]
struct Person {
name: String,
age: u32,
}Den Vektor erstellen
Erstellen Sie Instanzen des Structs und sammeln Sie sie anschließend in einem vec!-Makro. Der Typ des Vektors wird automatisch zu Vec<Person>.
Verwenden Sie {:?}, um alle Datensätze auf einmal auszugeben.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 25 },
];
println!("{:?}", people);
}Structs mit push hinzufügen
Sie können auch mit einem leeren Vektor beginnen und Structs einzeln mit push hinzufügen. Der Vektor muss mut sein, damit er wachsen kann.
Dieses Muster eignet sich, wenn Datensätze nach und nach eintreffen, etwa durch Benutzereingaben.
#[derive(Debug)]
struct Item { name: String }
fn main() {
let mut cart = Vec::new();
cart.push(Item { name: String::from("Pen") });
cart.push(Item { name: String::from("Mug") });
println!("{:?}", cart);
}Datensätze durchlaufen
Durchlaufen Sie &people, um jedes Struct zu lesen, ohne dessen Ownership zu übernehmen. Innerhalb der Schleife greifen Sie mit der Punktnotation auf Felder zu, etwa mit p.name.
So wird für jeden Datensatz eine verständliche Zeile ausgegeben.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 25 },
];
for p in &people {
println!("{} is {}", p.name, p.age);
}
}Ein Feld lesen
Greifen Sie per Index auf den Vektor zu, um ein Struct zu erreichen, und verwenden Sie anschließend die Punktnotation für dessen Feld. people[0].name liefert also den Namen der ersten Person.
Denken Sie daran: Indizes beginnen bei 0, und ein Zugriff außerhalb des gültigen Bereichs führt zu einer Panik.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
];
println!("name: {}", people[0].name);
}Ein Feld ändern
Um einen Datensatz zu bearbeiten, muss der Vektor mut sein. Greifen Sie dann per Index auf das Struct zu und weisen Sie seinem Feld einen Wert zu, etwa mit people[0].age = 31.
Dadurch werden die gespeicherten Daten direkt geändert.
struct Person { name: String, age: u32 }
fn main() {
let mut people = vec![
Person { name: String::from("Ann"), age: 30 },
];
people[0].age = 31;
println!("{}", people[0].age);
}Ein Feld summieren
Iteratoren können aus jedem Datensatz ein einzelnes Feld auswählen. Hier addiert iter().map(|p| p.age).sum() alle Altersangaben.
Der Schritt map wandelt jede Person vor dem Summieren in ihr Alter um.
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
let total: u32 = people.iter().map(|p| p.age).sum();
println!("total age = {}", total);
}Datensätze filtern
Verwenden Sie iter().filter(...), um Datensätze zu behalten, die einer Regel entsprechen. Die Closure gibt für jedes Struct einen booleschen Wert zurück.
Hier zählen wir, wie viele Personen mindestens 30 Jahre alt sind.
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
let adults = people.iter().filter(|p| p.age >= 30).count();
println!("adults: {}", adults);
}Nach einem Feld sortieren
Sortieren Sie Datensätze nach einem Feld mit sort_by_key. Übergeben Sie eine Closure, die den Wert zurückgibt, nach dem sortiert werden soll, etwa das Alter.
Der Vektor muss mut sein, weil das Sortieren seine Reihenfolge verändert.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let mut people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
people.sort_by_key(|p| p.age);
println!("{:?}", people);
}Datensätze zählen
Die Anzahl der gespeicherten Structs lässt sich wie bei jedem Vektor einfach mit len() ermitteln. So erfahren Sie, wie viele Datensätze aktuell enthalten sind.
Kombinieren Sie dies mit is_empty(), um vor dem Lesen des ersten Datensatzes zu prüfen, ob der Vektor leer ist.
struct Item { name: String }
fn main() {
let cart = vec![
Item { name: String::from("Pen") },
Item { name: String::from("Mug") },
];
println!("items: {}", cart.len());
}Kurzer Test
Testen Sie Ihr Verständnis von Vektoren aus Structs.
Zusammenfassung
Sie haben Structs in einem Vec gespeichert, ihn mit vec! und push aufgebaut und Felder per Index sowie in Schleifen gelesen oder bearbeitet.
Außerdem haben Sie summiert, gefiltert, nach einem Feld sortiert und Datensätze gezählt. Nun können Sie mit Vektoren Listen strukturierter Daten verwalten.
Häufig gestellte Fragen
Ist die Lektion „Vektoren aus Structs“ kostenlos?
Ja — der vollständige Text von „Vektoren aus Structs“ 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 „Vektoren aus Structs“?
Speichern Sie komplexe Daten in einem Vec. 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 „Vektoren aus Structs“?
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
- Vektoren erstellen und füllen
- Indizieren und iterieren
- Vergrößern und verkleinern
- Vektoren aus Structs