Learn Rust Coding · Lektion

Strings und &str

Eigener und geliehener Text

Strings und &str 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.

Zwei String-Typen

Rust hat zwei wichtige Texttypen:

String — ein eigener, vergrößerbarer String.
&str — ein ausgeliehener String-Slice, also eine Ansicht auf Text.

fn main() {
    let owned: String = String::from("hello");
    let borrowed: &str = "world";
    println!("{} {}", owned, borrowed);
}

String-Literale sind &str

Wenn Sie Text in doppelte Anführungszeichen schreiben, erhalten Sie ein &str. Es ist unveränderlich und wird im Programmbinärfile gespeichert.

fn main() {
    let greeting = "Hi there"; // type is &str
    println!("{}", greeting);
}

Einen String erstellen

Erstellen Sie einen eigenen String mit String::from oder der Methode .to_string().

fn main() {
    let a = String::from("abc");
    let b = "xyz".to_string();
    println!("{} {}", a, b);
}

Einen String vergrößern

Da String eigene Daten besitzt und vergrößerbar ist, können Sie mit push_str und push Text anhängen.

fn main() {
    let mut s = String::from("Hello");
    s.push_str(", ");
    s.push_str("Rust");
    s.push('!');
    println!("{}", s);
}

Verketten

Verbinden Sie Strings mit dem Operator + oder dem Makro format!. format! verbraucht seine Eingaben nicht.

fn main() {
    let first = String::from("Hello");
    let second = String::from("World");
    let joined = format!("{} {}", first, second);
    println!("{}", joined);
}

Einen String als &str ausleihen

Ein String kann automatisch als &str ausgeliehen werden. Dadurch können Funktionen beide Typen akzeptieren.

fn print_text(text: &str) {
    println!("text: {}", text);
}

fn main() {
    let owned = String::from("owned");
    print_text(&owned);
    print_text("literal");
}

Warum &str-Parameter bevorzugen?

Funktionen akzeptieren normalerweise &str statt String. Das ist flexibler: Aufrufer können eigene Strings, Literale oder Slices übergeben.

fn shout(s: &str) -> String {
    s.to_uppercase()
}

fn main() {
    println!("{}", shout("quiet"));
}

Länge in Bytes

Die Methode len() gibt die Länge in Bytes, nicht in Zeichen, zurück. ASCII-Text verwendet ein Byte pro Zeichen.

fn main() {
    let s = "hello";
    println!("{} bytes", s.len());
}

Inhalt prüfen

Nützliche Methoden zum Lesen sind contains, starts_with und is_empty.

fn main() {
    let s = "hello world";
    println!("{}", s.contains("world"));
    println!("{}", s.starts_with("hello"));
}

Unterschied beim Besitz

Ein String besitzt seine Daten auf dem Heap und ist dafür verantwortlich, sie freizugeben. Ein &str leiht lediglich vorhandene Daten aus und besitzt nichts.

fn main() {
    let owned = String::from("data");
    let view: &str = &owned[0..2];
    println!("owned {} view {}", owned, view);
}

Zwischen beiden konvertieren

Konvertieren Sie in beide Richtungen:

&str zu String: .to_string() oder String::from.
String zu &str: &s oder s.as_str().

fn main() {
    let s = String::from("convert");
    let slice: &str = s.as_str();
    let back: String = slice.to_string();
    println!("{} {}", slice, back);
}

Kurze Überprüfung

Rufen Sie sich den Unterschied zwischen den beiden Texttypen ins Gedächtnis.

Zusammenfassung

Strings in Rust:

String — eigener, vergrößerbarer String auf dem Heap.
&str — ausgeliehener Slice bzw. ausgeliehene Ansicht, wie sie Literale darstellen.
Erstellen Sie ihn mit String::from oder to_string(); vergrößern Sie ihn mit push_str.
Bevorzugen Sie &str für Funktionsparameter.

fn main() {
    let mut msg = String::from("Rust");
    msg.push_str(" rocks");
    let view: &str = &msg;
    println!("{} ({} bytes)", view, view.len());
}

Häufig gestellte Fragen

Ist die Lektion „Strings und &str“ kostenlos?

Ja — der vollständige Text von „Strings und &str“ 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 „Strings und &str“?

Eigener und geliehener Text 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 „Strings und &str“?

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