Learn Rust Coding · Lektion

Vektoren

Dynamisch wachsende Arrays

Vektoren ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

What Is a Vector?

A Vec<T> is a growable array. Unlike a fixed-size array, a vector can grow or shrink at runtime.

All elements must be the same type T.

fn main() {
    let v: Vec<i32> = Vec::new();
    println!("empty vector with length {}", v.len());
}

Creating with vec!

The vec! macro is the easiest way to create a vector with initial values.

fn main() {
    let numbers = vec![1, 2, 3, 4];
    println!("{:?}", numbers);
}

Adding Elements

Use push to append an element to the end. The vector must be mut to change it.

fn main() {
    let mut v = Vec::new();
    v.push(10);
    v.push(20);
    v.push(30);
    println!("{:?}", v);
}

Removing Elements

pop removes and returns the last element wrapped in an Option. It returns None if the vector is empty.

fn main() {
    let mut v = vec![1, 2, 3];
    let last = v.pop();
    println!("removed {:?}, now {:?}", last, v);
}

Accessing by Index

Index a vector with square brackets, just like an array. An out-of-range index causes a panic.

fn main() {
    let v = vec!["a", "b", "c"];
    println!("first {}", v[0]);
    println!("third {}", v[2]);
}

Safe Access with get

The get method returns an Option instead of panicking, which is safer for unknown indices.

fn main() {
    let v = vec![10, 20, 30];
    match v.get(5) {
        Some(x) => println!("found {}", x),
        None => println!("no element there"),
    }
}

Iterating a Vector

Loop over a vector's elements with a for loop. Use & to borrow each element without taking ownership.

fn main() {
    let v = vec![100, 200, 300];
    for item in &v {
        println!("item {}", item);
    }
}

Mutating While Iterating

Iterate with &mut to modify each element in place. Dereference with * to change the value.

fn main() {
    let mut v = vec![1, 2, 3];
    for item in &mut v {
        *item *= 10;
    }
    println!("{:?}", v);
}

Vector Length and Emptiness

Use len() for the number of elements and is_empty() to check if there are none.

fn main() {
    let v = vec![5, 6];
    println!("len {} empty {}", v.len(), v.is_empty());
}

Common Vector Methods

Vectors offer many helpers:

contains — check membership.
first / last — get ends as Option.
sort — order the elements.

fn main() {
    let mut v = vec![3, 1, 2];
    v.sort();
    println!("{:?} contains 2: {}", v, v.contains(&2));
}

Summing with Iterators

Combine vectors with iterator methods to compute totals concisely.

fn main() {
    let v = vec![10, 20, 30, 40];
    let total: i32 = v.iter().sum();
    println!("total {}", total);
}

Quick Check

Recall the method that grows a vector.

Recap

Vectors in Rust:

Vec<T> is a growable, same-type list.
Create with Vec::new() or vec![...].
push adds, pop removes from the end.
Access with [] or safely with get.
Iterate with for x in &v.

fn main() {
    let mut scores = vec![80, 90];
    scores.push(100);
    let avg: i32 = scores.iter().sum::<i32>() / scores.len() as i32;
    println!("average {}", avg);
}

Häufig gestellte Fragen

Ist die Lektion „Vektoren“ kostenlos?

Ja — der vollständige Text von „Vektoren“ 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“?

Dynamisch wachsende Arrays 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 1 von 4.

Wie lange dauert die Lektion „Vektoren“?

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

← Zurück zu Learn Rust Coding