Les slices comme paramètres de fonction

Fait partie de la section Logique & Flux 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 seconde 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 la longueur maximale, la fonction doit renvoyer une tranche du message jusqu’à la longueur maximale. Sinon, elle doit renvoyer le message entier. Affichez le résultat.

Exigences :

Lisez la première entrée (le message texte) et supprimez les espaces superflus
Lisez la seconde entrée (la longueur maximale) et supprimez les espaces superflus
Analysez la longueur maximale en usize
Définissez une fonction truncate_message qui prend deux paramètres :
- Une tranche de chaîne &str pour le message
- Un usize pour la longueur maximale
Dans la fonction, vérifiez si la longueur du message est supérieure à la longueur maximale
Si oui, renvoyez une tranche du message de l’index 0 à la longueur maximale en utilisant &message[0..max_len]
Sinon, renvoyez le message entier
Appelez la fonction avec le message d’entrée et la longueur maximale
Affichez le résultat renvoyé

Entrée :

Première ligne : Un message texte (par ex. Hello World from Rust)
Deuxième ligne : Longueur maximale sous forme de nombre (par ex. 11)

Sortie :

Le message tronqué s’il dépasse la longueur maximale, ou le message complet dans le cas contraire

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
}