Learn Rust Coding · Leçon

Chaînes et &str

Texte possédé et emprunté

Chaînes et &str est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 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.

Deux types de chaînes

Rust possède deux principaux types de texte :

String — une chaîne dont vous avez la propriété et qui peut grandir.
&str — une tranche de chaîne empruntée, qui offre une vue sur le texte.

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

Les littéraux de chaîne sont des &str

Lorsque vous écrivez du texte entre guillemets doubles, vous obtenez un &str. Il est fixe et stocké dans le binaire du programme.

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

Créer une chaîne

Construisez une String dont vous avez la propriété avec String::from ou la méthode .to_string().

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

Faire grandir une chaîne

Comme String vous appartient et peut grandir, vous pouvez lui ajouter du texte avec push_str et push.

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

Concaténation

Assemblez des chaînes avec l'opérateur + ou la macro format!. format! ne consomme pas ses entrées.

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

Emprunter une String comme &str

Une String peut être automatiquement empruntée comme &str. Cela permet aux fonctions d'accepter l'un ou l'autre type.

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

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

Pourquoi préférer les paramètres &str

Les fonctions acceptent généralement &str plutôt que String. C'est plus flexible : l'appelant peut transmettre des chaînes dont il a la propriété, des littéraux ou des tranches.

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

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

Longueur en octets

La méthode len() renvoie la longueur en octets, et non en caractères. Le texte ASCII utilise un octet par caractère.

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

Vérifier le contenu

Parmi les méthodes de lecture utiles figurent contains, starts_with et is_empty.

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

Différence de propriété

Une String possède ses données sur le tas et est responsable de leur libération. Un &str emprunte simplement des données existantes et ne possède rien.

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

Convertir de l'un à l'autre

Convertissez dans les deux sens :

De &str vers String : .to_string() ou String::from.
De String vers &str : &s ou 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);
}

Vérification rapide

Rappelez-vous la différence entre les deux types de texte.

Récapitulatif

Les chaînes en Rust :

String — possède ses données, peut grandir et est allouée sur le tas.
&str — tranche ou vue empruntée, utilisée par les littéraux.
Créez-en une avec String::from ou to_string() ; faites-la grandir avec push_str.
Préférez &str pour les paramètres de fonction.

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

Questions Fréquemment Posées

La leçon « Chaînes et &str » est-elle gratuite ?

Oui — le texte complet de « Chaînes et &str » 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 « Chaînes et &str » ?

Texte possédé et emprunté 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 2 sur 4.

Combien de temps prend la leçon « Chaînes et &str » ?

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