Accolades en Rust : comment afficher { et } dans format! sans erreurs

Introduction : pourquoi Rust n'aime-t-il pas les accolades ?

Si vous avez déjà écrit en Rust et essayé d'afficher quelque chose comme { "name": "Rust" } via println!, vous avez sûrement vu ceci :

println!("{ "name": "Rust" }"); // Erreur de compilation !

Le compilateur annonce malicieusement : "invalid reference to argument 'name' — no argument named 'name' found". Et vous restez perplexe : comment afficher des accolades dans une chaîne ? En Python, cela se fait avec {{ }}, mais c'est plus simple là-bas. Rust a sa propre philosophie : les accolades ne sont pas de simples caractères, mais une partie d'un puissant système de formatage, emprunté à Python, mais avec des nuances.

Dans cet article, nous allons voir toutes les méthodes d'échappement des accolades en Rust : du basique {{ }} aux astuces avec Debug et raw string literals. Vous apprendrez à afficher du JSON, générer du code et travailler avec des modèles sans tomber dans les pièges du compilateur.

Pourquoi les accolades sont-elles spéciales ?

En Rust, les macros format!, println!, write! et format_args! utilisent les accolades comme marqueurs de substitution. Par exemple :

let name = "Rust";\nprintln!("Hello, {}!", name); // Hello, Rust!

Ici, {} est un placeholder qui est remplacé par la valeur de la variable. Mais que faire si vous avez besoin du symbole { ou } lui-même ? Rust utilise une astuce simple : le doublement des accolades.

Méthode 1 : Le doublement classique {{ et }}

La méthode la plus simple et évidente est d'écrire deux accolades à la suite. La première paire {{ se transforme en une seule {, et }} en une seule }.

Exemple 1 : Échappement simple

fn main() {\n    let text = format!("Fonction main() {{ ... }}");\n    println!("{}", text);\n    // Affichage : Fonction main() { ... }\n}

Exemple 2 : Échappement avec substitution

fn main() {\n    let lang = "Rust";\n    let year = 2015;\n    let result = format!("{{ \\"lang\\": \\"{}\\", \\"year\\": {} }}", lang, year);\n    println!("{}", result);\n    // Affichage : { "lang": "Rust", "year": 2015 }\n}

Cette méthode fonctionne partout : dans println!, write!, format!. Retenez la règle : deux accolades = une accolade.

Méthode 2 : Arguments nommés et échappement

Si vous utilisez des arguments nommés (par exemple, {name}), l'échappement fonctionne aussi, mais il faut être attentif à la position des accolades.

Exemple 3 : Placeholders nommés et accolades

fn main() {\n    let user = "Alice";\n    // Nous voulons afficher : Bonjour, {Alice}!\n    println!("Bonjour, {{{}}}!", user);\n    // Affichage : Bonjour, {Alice}!\n}

Décortiquons la chaîne "Bonjour, {{{}}}!" :\n

\n
• {{ → affiche {
\n
• {} → substitue user
\n
• }} → affiche }
\n

Important : le nombre d'accolades est toujours pair pour l'échappement. Si vous avez {{{ — c'est une erreur, car trois accolades ne forment pas une paire correcte.

Méthode 3 : Utilisation du format Debug ({:?})

Parfois, vous voulez afficher une structure de données pour qu'elle apparaisse automatiquement avec des accolades. Par exemple, lors du débogage ou de la génération de JSON.

Exemple 4 : Affichage d'une structure via Debug

#[derive(Debug)]\nstruct Point {\n    x: i32,\n    y: i32,\n}\n\nfn main() {\n    let p = Point { x: 10, y: 20 };\n    println!("{:?}", p);\n    // Affichage : Point { x: 10, y: 20 }\n}

Le trait Debug ajoute lui-même des accolades autour des champs. C'est pratique si vous voulez montrer rapidement l'état d'un objet. Mais si vous avez besoin de JSON ou d'aut