Les slices comme paramètres de fonction

Fait partie de la section Logic & Flow du Journey Rust de Coddy — leçon 56 sur 66.

Lors de l'écriture de fonctions qui travaillent avec des chaînes de caractères, l'utilisation de &str comme type de paramètre au lieu de String rend vos fonctions beaucoup plus flexibles et utiles.

Une fonction qui prend un paramètre String ne peut accepter que des chaînes possédées (owned), ce qui limite la façon dont vous pouvez l'appeler :

fn print_message(text: String) {
    println!("{}", text);
}

// Cela fonctionne, mais prend la possession (ownership)
let my_string = String::from("Hello");
print_message(my_string); // my_string n'est plus utilisable après cela

Cependant, une fonction qui prend &str peut accepter à la fois des références de String et des littéraux de chaîne, ce qui la rend beaucoup plus polyvalente :

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

// Maintenant, vous pouvez l'appeler avec l'un ou l'autre type
let my_string = String::from("Hello");
print_message(&my_string); // Passer une référence à String
print_message("World");     // Passer un littéral de chaîne directement

Cette flexibilité signifie que vos fonctions fonctionnent dans davantage de situations sans forcer les appelants à convertir leurs données ou à céder la propriété.

Défi

Facile

Vous recevrez deux entrées. La première entrée est un message texte, et la deuxième entrée est la longueur maximale autorisée pour le message. Créez une fonction appelée truncate_message qui prend une tranche de chaîne (&str) et une longueur maximale (usize) comme paramètres. Si la longueur du message dépasse le maximum, la fonction doit retourner une tranche du message jusqu'à la longueur maximale. Sinon, elle doit retourner le message entier. Affichez le résultat.

Exigences :

Lire la première entrée (le message texte) et supprimer les espaces blancs (trim)
Lire la deuxième entrée (la longueur maximale) et supprimer les espaces blancs (trim)
Convertir (parse) la longueur maximale en usize
Définir une fonction truncate_message qui prend deux paramètres :
- Une tranche de chaîne &str pour le message
- Un usize pour la longueur maximale
À l'intérieur de la fonction, vérifier si la longueur du message est supérieure à la longueur maximale
Si oui, retourner une tranche du message de l'index 0 à la longueur maximale en utilisant &message[0..max_len]
Si non, retourner le message entier
Appeler la fonction avec le message d'entrée et la longueur maximale
Afficher le résultat retourné

Entrée :

Première ligne : Un message texte (par exemple, Hello World from Rust)
Deuxième ligne : La longueur maximale sous forme de nombre (par exemple, 11)

Sortie :

Le message tronqué s'il dépasse la longueur maximale, ou le message complet sinon

Aide-mémoire

Utiliser &str comme type de paramètre rend les fonctions plus flexibles que l'utilisation de String, car elles peuvent accepter à la fois des références de chaînes et des littéraux de chaînes :

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

let my_string = String::from("Hello");
print_message(&my_string); // Passer une référence à String
print_message("World");     // Passer un littéral de chaîne directement

Pour retourner une tranche d'une chaîne jusqu'à une certaine longueur, utilisez la syntaxe de tranche :

&message[0..max_len]

Essayez vous-même

use std::io;

// TODO: Définir la fonction truncate_message ici


fn main() {
    // Lire le message texte
    let mut message = String::new();
    io::stdin().read_line(&mut message).expect("Failed to read line");
    let message = message.trim();
    
    // Lire la longueur maximale
    let mut max_length_input = String::new();
    io::stdin().read_line(&mut max_length_input).expect("Failed to read line");
    let max_len: usize = max_length_input.trim().parse().expect("Invalid number");
    
    // TODO: Appeler la fonction truncate_message et stocker le résultat
    
    // TODO: Imprimer le résultat
}