Slices
Geliehene Sichten
Slices ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 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.
Was ist ein Slice?
Ein Slice ist eine ausgeliehene Ansicht auf einen zusammenhängenden Teil einer Sammlung. Er besitzt keine Daten — er zeigt auf bereits vorhandene Daten.
Slices werden mit einem Bereich in eckigen Klammern geschrieben.
fn main() {
let arr = [1, 2, 3, 4, 5];
let part = &arr[1..4];
println!("{:?}", part);
}Syntax für Slice-Bereiche
Bereiche wählen einen Start- und einen Endindex aus. Das Ende ist exklusiv.
&v[1..4]— Indizes 1, 2, 3.&v[..3]— vom Anfang bis 3.&v[2..]— von 2 bis zum Ende.
fn main() {
let v = vec![10, 20, 30, 40];
println!("{:?}", &v[..2]);
println!("{:?}", &v[2..]);
}String-Slices
Ein String-Slice &str ist eine Ansicht auf einen Teil eines String. Indexbereiche beziehen sich auf die Position in Bytes.
fn main() {
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];
println!("{} {}", hello, world);
}Slices ganzer Sammlungen
Verwenden Sie &v[..], um die gesamte Sammlung als Slice auszuleihen. So wird ein Vec als Slice ausgeliehen.
fn main() {
let v = vec![1, 2, 3];
let whole = &v[..];
println!("{:?}", whole);
}Slices als Parameter
Funktionen, die &[T] entgegennehmen, akzeptieren sowohl Arrays als auch Vektoren. Dadurch sind sie flexibel einsetzbar.
fn sum(items: &[i32]) -> i32 {
let mut total = 0;
for x in items {
total += x;
}
total
}
fn main() {
let v = vec![1, 2, 3];
let a = [4, 5, 6];
println!("{} {}", sum(&v), sum(&a));
}Slices leihen aus, sie besitzen nicht
Da ein Slice Daten ausleiht, muss die ursprüngliche Sammlung so lange gültig bleiben, wie der Slice verwendet wird. Der Compiler erzwingt dies.
fn main() {
let v = vec![100, 200, 300];
let s = &v[0..2];
println!("slice {:?}, original {:?}", s, v);
}Länge eines Slice
Wie andere Sammlungen besitzen Slices eine len()-Methode, die die Anzahl der von ihnen abgedeckten Elemente angibt.
fn main() {
let v = vec![5, 6, 7, 8, 9];
let middle = &v[1..4];
println!("length {}", middle.len());
}first und last
Slices stellen first() und last() bereit. Diese geben Options zurück, sodass leere Slices sicher behandelt werden.
fn main() {
let data = [10, 20, 30];
let s = &data[..];
println!("{:?} {:?}", s.first(), s.last());
}Einen Slice durchlaufen
Sie können einen Slice wie jede andere Sammlung durchlaufen.
fn main() {
let v = vec![1, 2, 3, 4];
for x in &v[1..3] {
println!("{}", x);
}
}Eine Funktion für das erste Wort
Ein typischer Anwendungsfall für Slices: eine Ansicht auf vorhandenen Text zurückgeben, etwa das erste Wort eines Satzes.
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &b) in bytes.iter().enumerate() {
if b == b' ' {
return &s[0..i];
}
}
s
}
fn main() {
println!("{}", first_word("hello there"));
}Warum Slices sicher sind
Slices vermeiden das Kopieren von Daten und verhindern gleichzeitig hängende Referenzen. Der Borrow Checker garantiert, dass die zugrunde liegenden Daten länger als der Slice gültig bleiben.
fn main() {
let words = vec!["a", "b", "c", "d"];
let pair = &words[1..3];
println!("{:?}", pair);
}Kurze Überprüfung
Rufen Sie sich ins Gedächtnis, wofür ein Slice steht.
Zusammenfassung
Slices in Rust:
- Eine ausgeliehene Ansicht:
&v[start..end], das Ende ist exklusiv. &strist ein String-Slice;&[T]ist ein Array- oder Vektor-Slice.- Slice-Parameter akzeptieren sowohl Arrays als auch Vektoren.
- Der Borrow Checker hält Slices sicher.
fn average(nums: &[i32]) -> i32 {
nums.iter().sum::<i32>() / nums.len() as i32
}
fn main() {
let v = vec![4, 8, 12];
println!("{}", average(&v[..]));
}Häufig gestellte Fragen
Ist die Lektion „Slices“ kostenlos?
Ja — der vollständige Text von „Slices“ 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 „Slices“?
Geliehene Sichten 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 4.
Wie lange dauert die Lektion „Slices“?
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.