Échappement de chaînes

Qu'est-ce que l'échappement de chaînes ?

L'échappement de chaînes est le processus qui consiste à insérer une barre oblique inverse (ou un autre marqueur) devant les caractères qui ont une signification particulière à l'intérieur d'un littéral de chaîne. Lorsque le parseur d'un langage de programmation rencontre un guillemet double à l'intérieur d'une chaîne délimitée par des guillemets doubles, il l'interprète comme la fin de la chaîne. Échapper le guillemet avec une barre oblique inverse — écrire \" au lieu de " — indique au parseur de le traiter comme un caractère littéral, et non comme un délimiteur. Tout langage utilisant des littéraux de chaîne possède des règles d'échappement, même si les séquences exactes diffèrent.

Les séquences d'échappement les plus courantes correspondent à des espaces blancs et à des caractères de contrôle qui ne peuvent pas apparaître directement dans le code source. Un saut de ligne devient \n, une tabulation devient \t, et une barre oblique inverse littérale devient \\. Ces conventions remontent au langage C (ISO/IEC 9899) et ont été adoptées par JavaScript (ECMA-262), Python, Java, Go et Rust. JSON (RFC 8259) utilise la même syntaxe mais prend en charge un ensemble de séquences plus restreint.

Le déséchappement (parfois appelé « suppression des échappements ») est l'opération inverse : convertir les séquences d'échappement en leurs caractères d'origine. Cette opération est courante lors de la lecture de fichiers journaux, de l'analyse de réponses API, ou du débogage de données qui ont été doublement échappées. Ces deux opérations sont mécaniques et sujettes aux erreurs lorsqu'elles sont effectuées manuellement, c'est pourquoi les développeurs utilisent un outil d'échappement/déséchappement lorsqu'ils travaillent avec des chaînes multilignes, des guillemets imbriqués ou des caractères Unicode.

Pourquoi utiliser un outil d'échappement de chaînes en ligne ?

Ajouter ou supprimer manuellement des barres obliques inverses est fastidieux et source d'erreurs, en particulier avec des guillemets imbriqués ou des entrées multilignes. Un outil d'échappement de chaînes dans le navigateur vous donne des résultats instantanés sans avoir à configurer un REPL ni à écrire des scripts jetables.

Cas d'utilisation de l'échappement de chaînes

Référence des séquences d'échappement

Le tableau ci-dessous répertorie les séquences d'échappement courantes et indique si elles sont prises en charge par JavaScript, Python et JSON. Les trois langages partagent le même ensemble de base (saut de ligne, tabulation, barre oblique inverse, guillemet double), mais divergent sur les guillemets simples, les échappements hexadécimaux et la notation Unicode étendue.

JavaScript vs Python vs JSON : comparaison de l'échappement

Bien que ces trois formats partagent la même syntaxe à base de barre oblique inverse, ils diffèrent quant aux séquences valides et à la gestion des cas limites. Choisir le mauvais mode produit une sortie qui semble correcte mais échoue à l'analyse.

Exemples de code

Exemples d'échappement et de déséchappement de chaînes en JavaScript, Python, Go et en ligne de commande.

// Escape a string with special characters
const raw = 'Line 1\nLine 2\tTabbed "quoted"';
const escaped = JSON.stringify(raw);
// → '"Line 1\\nLine 2\\tTabbed \\"quoted\\""'

// Unescape a JSON string value
const input = '"Hello\\nWorld"';
const unescaped = JSON.parse(input);
// → "Hello\nWorld" (actual newline character)

// Template literals don't need quote escaping
const tpl = `She said "hello"`;
// → 'She said "hello"' — no backslashes needed

// Escape for use inside a RegExp
const query = 'price: $5.00 (USD)';
const safe = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
// → "price: \\$5\\.00 \\(USD\\)"

# Escape with repr() — shows escape sequences
raw = "Line 1\nLine 2\t'quoted'"
print(repr(raw))
# → "Line 1\nLine 2\t'quoted'"

# Raw strings skip escape processing
path = r"C:\Users\name\Documents"
print(path)
# → C:\Users\name\Documents (backslashes kept literal)

# JSON escaping with json module
import json
data = 'He said "hello\nworld"'
escaped = json.dumps(data)
# → '"He said \\"hello\\nworld\\""'

# Unicode escaping
text = "Caf\u00e9"  # → "Café"
print(text.encode('unicode_escape').decode())
# → "Caf\\xe9"

package main

import (
    "fmt"
    "strconv"
    "encoding/json"
)

func main() {
    // strconv.Quote adds escape sequences and wraps in quotes
    raw := "Line 1\nLine 2\t\"quoted\""
    fmt.Println(strconv.Quote(raw))
    // → "\"Line 1\\nLine 2\\t\\\"quoted\\\"\""

    // strconv.Unquote reverses it
    unescaped, _ := strconv.Unquote(`"hello\nworld"`)
    fmt.Println(unescaped)
    // → hello
    //   world

    // JSON marshal handles escaping automatically
    b, _ := json.Marshal("tabs\there & \"quotes\"")
    fmt.Println(string(b))
    // → "tabs\there \u0026 \"quotes\""
}

# Use $'...' syntax for escape sequences in bash
echo $'Line 1\nLine 2\tTabbed'
# → Line 1
#    Line 2	Tabbed

# printf interprets escape sequences
printf 'Path: C:\\Users\\name\n'
# → Path: C:\Users\name

# Use jq to escape a string for JSON
echo 'He said "hello"' | jq -Rs .
# → "He said \"hello\"\n"

# Unescape JSON string with jq
echo '"Line 1\\nLine 2"' | jq -r .
# → Line 1
#    Line 2

Questions fréquentes