Strings in Rust

Was lerne ich in diesem Kurs?

In diesem Tutorial lernen wir die verschiedenen String-Typen in Rust kennen, wie sie sich unterscheiden und wann sie verwendet werden sollten.

Die zwei String-Typen in Rust sind:

• str (String-Slice)
• String

1. Der str Typ

Der Typ str (auch als String-Slice bekannt) ist eine Art unveränderliche Zeichenkette. Es handelt sich um eine Ansammlung von Textdaten, die in der Regel durch Referenzen (&str) verwendet wird. Im Gegensatz zu String ist str eine "borrowed" (geliehene) Zeichenkette, was bedeutet, dass der Speicherort, auf den es verweist, nicht durch das str-Objekt selbst verwaltet wird.

Beispiel: Verwendung von &str

fn main() {
    let text: &str = "Hello, Rust!";
    println!("{}", text);
}

Wichtige Eigenschaften von &str: - Unveränderlich: Ein &str-Slice kann nicht direkt modifiziert werden. - Borrowed (geliehen): Der Speicher, auf den ein &str verweist, wird nicht durch &str verwaltet, sondern vom Besitzer des ursprünglichen Strings. - Effizient: Da &str unveränderlich ist und keine Speicherzuweisung erfolgt, ist es sehr speicher- und laufzeitfreundlich.

String-Literale sind &str

In Rust sind String-Literale, wie "Hello, World!", vom Typ &str. Sie sind fest in das Programm eingebettet und somit unveränderlich.

fn main() {
    let literal = "I am an immutable string slice";  // `literal` ist vom Typ `&str`
    println!("{}", literal);
}

2. Der String Typ

Der String-Typ ist eine eigentümliche (owned) Zeichenkette, die im Heap gespeichert wird. String ist dynamisch und erlaubt es, Zeichenketten zur Laufzeit zu erstellen und zu ändern.

Beispiel: Erstellung und Modifikation eines String

fn main() {
    let mut my_string = String::from("Hello, ");
    my_string.push_str("Rust!");  // Modifiziert den String

    println!("{}", my_string);
}

Wichtige Eigenschaften von String: - Veränderlich: Ein String kann nachträglich modifiziert werden. - Owned (Eigentümer): Der String-Typ besitzt den Speicher und verwaltet ihn automatisch (z. B. mit automatischem Speicherfreigeben via Rusts Ownership-Modell). - Heap-gespeichert: Der Speicher wird dynamisch im Heap zugewiesen, was bedeutet, dass die Größe des Strings zur Laufzeit wachsen oder schrumpfen kann.

String-Erstellung

Es gibt verschiedene Möglichkeiten, einen String in Rust zu erstellen:

1. Mit String::from

fn main() {
    let s = String::from("Hello, World!");
    println!("{}", s);
}

2. Mit to_string

fn main() {
    let s = "Hello".to_string();
    println!("{}", s);
}

3. Leeren String erstellen

fn main() {
    let mut empty_string = String::new();  // Ein leerer String
    empty_string.push_str("Füge Text hinzu!");  // Text hinzufügen
    println!("{}", empty_string);
}

4. Konvertierung zwischen &str und String

Da &str und String unterschiedliche Eigenschaften haben, muss manchmal zwischen ihnen konvertiert werden.

4.1 Von &str zu String

Es gibt mehrere Möglichkeiten, ein &str in einen String zu konvertieren:

1. Mit String::from

fn main() {
    let s: &str = "Hello, Rust!";
    let s_string = String::from(s);
    println!("{}", s_string);
}

2. Mit to_string

fn main() {
    let s: &str = "Hello, Rust!";
    let s_string = s.to_string();
    println!("{}", s_string);
}

4.2 Von String zu &str

Ein String kann leicht in ein &str konvertiert werden, indem eine Referenz auf den String genommen wird:

fn main() {
    let s: String = String::from("Hello, Rust!");
    let s_slice: &str = &s;  // Eine Referenz auf den `String`
    println!("{}", s_slice);
}

5. Wann verwende ich &str und wann String?

Verwende &str:

• Wenn du unveränderlichen Text hast, z. B. Literale.
• Wenn du eine String-Referenz erwartest, wie in Funktionen, die nur Zugriff auf den Inhalt benötigen, ohne ihn zu verändern.

Verwende String:

• Wenn du dynamischen oder veränderlichen Text hast.
• Wenn du Text erstellen, modifizieren oder erweitern möchtest.