Qu'est-ce que r#""# en Rust ? Analyse complète de l'opérateur magique

Que se cache-t-il derrière le mystérieux r#""# en Rust ? Explication complète avec code

Avez-vous déjà rencontré dans du code Rust une étrange écriture comme r#"..."# en pensant : « Quel est cet opérateur magique ? Est-ce une syntaxe secrète réservée aux initiés ? » — vous n'êtes pas seul. Des milliers de développeurs ont posé cette question sur Stack Overflow, et aujourd'hui nous allons une fois pour toutes comprendre ce que c'est, à quoi ça sert et comment utiliser les littéraux de chaîne bruts (raw string literals) en Rust.

Dans cet article, nous ne donnerons pas simplement une définition sèche. Nous suivrons le chemin du problème à la solution, écrirons du code réel, verrons comment r#""# vous évite des maux de tête, et découvrirons où cette syntaxe est également utilisée. C'est parti !

Le problème : quand les chaînes ordinaires cassent le code

Imaginez que vous écrivez un analyseur JSON ou une expression régulière. À l'intérieur de la chaîne, vous devez utiliser des guillemets et des barres obliques inverses. En code Rust ordinaire, cela ressemble à un cauchemar :

let json_string = "{\\"name\\": \\"Rust\\", \\"year\\": 2015}";let regex = "\\\\d{2}-\\\\d{2}-\\\\d{4}"; // date au format JJ-MM-AAAA

Vous voyez ça ? Chaque fois que vous avez besoin d'un guillemet à l'intérieur de la chaîne, vous mettez une barre oblique inverse devant (\\"). Et si vous avez besoin de la barre oblique inverse elle-même, vous écrivez \\\\. Le code se transforme rapidement en une « échelle » de barres obliques difficile à lire et à déboguer.

Mais ce n'est que le début. Et si vous devez insérer un caractère de tabulation dans la chaîne ? Vous écrivez alors \\t. Et si vous avez besoin littéralement du texte \\t ? Il faut échapper : \\\\t. Les yeux commencent à piquer dès la deuxième ligne.

La solution : les chaînes brutes — r#""#

Rust propose une solution élégante : les littéraux de chaîne bruts. Ils sont désignés par le préfixe r et encadrés par # :

// Chaîne brute : tout ce qui est à l'intérieur est considéré comme du texte littérallet raw_json = r#"{"name": "Rust", "year": 2015}"#;let raw_regex = r#"\\d{2}-\\d{2}-\\d{4}"#;

Vous sentez la différence ? Pas d'échappement ! Les guillemets à l'intérieur sont de simples guillemets. Les barres obliques inverses sont de simples barres obliques. Le compilateur Rust perçoit le contenu entre r#" et "# comme du texte pur, sans essayer d'interpréter les séquences d'échappement.

C'est particulièrement utile lorsque vous travaillez avec :

• Les expressions régulières — elles sont pleines de barres obliques et de caractères spéciaux.
• JSON, XML, HTML — des chaînes avec beaucoup de guillemets.
• Les requêtes SQL — surtout avec des guillemets imbriqués.
• Les chemins de fichiers sous Windows — C:\\Users\\Name au lieu de C:\\\\Users\\\\Name.
• Toutes les données où la barre oblique inverse doit rester telle quelle.

Comment ça fonctionne sous le capot ?

Lorsque Rust rencontre r#"..."#, il copie simplement tout ce qui se trouve entre le r#" initial et le "# final dans la chaîne sans aucun traitement. Aucun ne se transforme en saut de ligne, aucun \\t ne devient une tabulation. C'est une tranche de texte littérale.

Mais il y a une nuance : que faire si à l'intérieur de la chaîne elle-même on rencontre la séquence "# ? Par exemple, vous voulez insérer le texte #"hello"#. Si vous écrivez r#"#"hello"#"#, le compilateur sera confus — où se termine le littéral ?

Pour cela, Rust a inventé les hachages multiples. Vous pouvez utiliser r##"..."##, r###"..."### et ainsi de suite. Le nombre de # des deux côtés doit correspondre :

// La chaîne contient "# à l'intérieur — utilisons des doubles hachageslet tricky = r##"Chaîne avec "# à l'intérieur"##;println!("{}", tricky); // Affiche : Chaîne avec "# à l'intérieur

// Et si elle contient "## ? Alors des triples hachages :let very_tricky = r###"Texte avec "## à l'intérieur"###;