Learn Rust Coding · Leçon

UTF-8 et caractères

Gestion d’Unicode

UTF-8 et caractères est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

Les chaînes Rust sont en UTF-8

Chaque String et chaque &str de Rust est encodé en UTF-8. Le texte peut ainsi contenir n’importe quel caractère Unicode, et pas seulement des caractères ASCII.

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

Qu’est-ce que UTF-8 ?

UTF-8 encode chaque caractère Unicode sur un à quatre octets. Les caractères ASCII utilisent un seul octet ; les lettres accentuées et les émojis en utilisent davantage.

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

Octets et caractères

En raison de l’encodage sur plusieurs octets, len() renvoie le nombre d’octets, tandis que le nombre de caractères peut être inférieur.

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

Le type char est Unicode

Un char Rust est une valeur de 4 octets qui peut contenir n’importe quelle valeur scalaire Unicode, bien au-delà d’un seul octet.

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

Parcourir les caractères

Utilisez chars() pour parcourir le texte caractère par caractère. Cette méthode gère correctement les caractères codés sur plusieurs octets.

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

Pourquoi l’indexation numérique est impossible

Rust n’autorise pas s[0] sur une chaîne. Comme les caractères peuvent avoir des tailles différentes en octets, une indexation par un seul nombre serait ambiguë et dangereuse.

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

Obtenir le caractère nth

Utilisez la méthode d’itérateur nth pour récupérer un caractère à une position donnée. Elle renvoie un Option.

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

Parcourir les octets

Lorsque vous avez réellement besoin des octets bruts, utilisez bytes(), qui produit des valeurs u8.

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

Découper aux limites des octets

Les tranches de chaînes utilisent des index en octets. Le découpage doit se faire sur une limite de caractère valide, sinon le programme provoque une panique.

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

Méthodes de char

Le type char possède des méthodes pratiques comme is_alphabetic, is_numeric et to_uppercase.

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

Compter des caractères précis

Combinez chars et filter pour compter les caractères qui correspondent à une condition.

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

Vérification rapide

Rappelez-vous pourquoi la longueur d’une chaîne peut vous surprendre.

Récapitulatif

UTF-8 et chars en Rust :

Les chaînes sont en UTF-8 ; les caractères utilisent de 1 à 4 octets.
len() donne le nombre d’octets ; chars().count() donne le nombre de caractères.
Vous ne pouvez pas indexer une chaîne par un nombre ; utilisez chars() ou nth.
Les tranches doivent se situer sur des limites de caractère.

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

Questions Fréquemment Posées

La leçon « UTF-8 et caractères » est-elle gratuite ?

Oui — le texte complet de « UTF-8 et caractères » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « UTF-8 et caractères » ?

Gestion d’Unicode Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « UTF-8 et caractères » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding