Learn Rust Coding · Lektion

UTF-8 und Chars

Unicode-Verarbeitung

UTF-8 und Chars 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.

Rust-Strings sind UTF-8

Jeder Rust-String und jedes &str ist als UTF-8 kodiert. Dadurch kann Text jedes Unicode-Zeichen enthalten, nicht nur ASCII.

fn main() {
    let s = String::from("caf\u{e9}");
    println!("{}", s);
}

Was ist UTF-8?

UTF-8 kodiert jedes Unicode-Zeichen mit einem bis vier Bytes. ASCII-Zeichen verwenden ein einzelnes Byte; Buchstaben mit Akzent und Emojis benötigen mehr.

fn main() {
    let ascii = "A";          // 1 byte
    let accent = "\u{e9}";    // 2 bytes (e-acute)
    println!("{} bytes vs {} bytes", ascii.len(), accent.len());
}

Bytes vs. Zeichen

Aufgrund der Mehrbyte-Kodierung gibt len() die Anzahl der Bytes zurück, während die Anzahl der Zeichen kleiner sein kann.

fn main() {
    let s = "caf\u{e9}";
    println!("bytes {}", s.len());
    println!("chars {}", s.chars().count());
}

Der Typ char ist Unicode

Ein Rust-char ist ein 4 Byte großer Wert, der jeden Unicode-Skalarwert aufnehmen kann und damit weit über ein einzelnes Byte hinausgeht.

fn main() {
    let letter = 'Z';
    let accented = '\u{f1}'; // n with tilde
    println!("{} {}", letter, accented);
}

Zeichen durchlaufen

Verwenden Sie chars(), um Text zeichenweise zu durchlaufen. Dadurch werden Mehrbyte-Zeichen korrekt verarbeitet.

fn main() {
    let s = "a\u{e9}z";
    for c in s.chars() {
        println!("{}", c);
    }
}

Warum Sie nicht per Zahl indizieren können

Rust erlaubt s[0] bei einem String nicht. Da Zeichen unterschiedlich viele Bytes belegen, wäre die Indizierung mit einer einzelnen Zahl mehrdeutig und unsicher.

fn main() {
    let s = "hello";
    // let c = s[0]; // error: cannot index a str
    let first = s.chars().next().unwrap();
    println!("{}", first);
}

Das n-te Zeichen abrufen

Verwenden Sie die Iterator-Methode nth, um ein Zeichen anhand seiner Position abzurufen. Sie gibt ein Option zurück.

fn main() {
    let s = "abcdef";
    let third = s.chars().nth(2);
    println!("{:?}", third);
}

Bytes durchlaufen

Wenn Sie tatsächlich rohe Bytes benötigen, verwenden Sie bytes(), das u8-Werte liefert.

fn main() {
    let s = "AB";
    for b in s.bytes() {
        println!("{}", b);
    }
}

An Byte-Grenzen slicen

String-Slices verwenden Byte-Indizes. Ein Slice muss an einer gültigen Zeichengrenze enden, andernfalls löst das Programm eine Panic aus.

fn main() {
    let s = "hello";
    let part = &s[0..3]; // valid ASCII boundary
    println!("{}", part);
}

char-Methoden

Der Typ char verfügt über nützliche Methoden wie is_alphabetic, is_numeric und to_uppercase.

fn main() {
    let c = 'k';
    println!("alpha {} numeric {}", c.is_alphabetic(), c.is_numeric());
    println!("upper {}", c.to_uppercase());
}

Bestimmte Zeichen zählen

Kombinieren Sie chars mit filter, um Zeichen zu zählen, die eine Bedingung erfüllen.

fn main() {
    let s = "banana";
    let a_count = s.chars().filter(|&c| c == 'a').count();
    println!("a appears {} times", a_count);
}

Kurze Überprüfung

Rufen Sie sich ins Gedächtnis, warum die Länge eines Strings überraschend sein kann.

Zusammenfassung

UTF-8 und chars in Rust:

Strings sind UTF-8; Zeichen benötigen 1 bis 4 Bytes.
len() liefert Bytes; chars().count() liefert Zeichen.
Sie können einen String nicht per Zahl indizieren; verwenden Sie chars() oder nth.
Slices müssen auf Zeichengrenzen liegen.

fn main() {
    let s = "sm\u{ee}le";
    println!("bytes {} chars {}", s.len(), s.chars().count());
    for c in s.chars() {
        print!("{} ", c);
    }
    println!();
}

Häufig gestellte Fragen

Ist die Lektion „UTF-8 und Chars“ kostenlos?

Ja — der vollständige Text von „UTF-8 und Chars“ 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 „UTF-8 und Chars“?

Unicode-Verarbeitung 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 „UTF-8 und Chars“?

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