String Escape

Vad är string escaping?

String escaping är processen att infoga ett bakåtstreck (eller annan markör) före tecken som har speciell betydelse inuti en strängliteral. När en programmeringsspråksparser stöter på ett dubbelt citattecken inuti en dubbelciterad sträng tolkar den det som strängslut. Att escapa citattecknet med ett bakåtstreck — skriva \" i stället för " — talar om för parsern att behandla det som ett bokstavligt tecken, inte en avgränsare. Varje språk som använder strängliteraler har escapingregler, men de exakta sekvenserna skiljer sig åt.

De vanligaste escape-sekvenserna avbildas på blanksteg och kontrolltecken som inte kan förekomma direkt i källkod. Ett radmatning blir \n, en tabb blir \t och ett bokstavligt bakåtstreck blir \\. Dessa konventioner härstammar från programspråket C (ISO/IEC 9899) och har antagits av JavaScript (ECMA-262), Python, Java, Go och Rust. JSON (RFC 8259) använder samma syntax men stödjer en mindre uppsättning sekvenser.

Unescaping (ibland kallat "de-escaping") är den omvända operationen: att konvertera escape-sekvenser tillbaka till sina ursprungliga tecken. Det är vanligt när man läser loggfiler, tolkar API-svar eller felsöker data som har dubbeleskapats. Båda operationerna är mekaniska och felbenägna när de utförs för hand, vilket är anledningen till att utvecklare använder ett escape/unescape-verktyg när de arbetar med flerradssträngar, inbäddade citattecken eller Unicode-tecken.

Varför använda ett online string escape-verktyg?

Att manuellt lägga till eller ta bort bakåtstreck är omständligt och lätt att göra fel, särskilt med kapslade citattecken eller flerradsinmatning. Ett webbläsarbaserat string escape-verktyg ger omedelbara resultat utan att behöva konfigurera en REPL eller skriva tillfälliga skript.

Användningsfall för string escaping

Referens för escape-sekvenser

Tabellen nedan listar vanliga escape-sekvenser och om de stöds i JavaScript, Python och JSON. Alla tre språken delar kärnuppsättningen (radmatning, tabb, bakåtstreck, dubbelt citattecken), men skiljer sig åt när det gäller enkla citattecken, hex-escape och utökad Unicode-notation.

JavaScript vs Python vs JSON-escaping

Även om dessa tre format delar samma bakåtstrecksbaserade syntax skiljer de sig åt i vilka sekvenser som är giltiga och hur de hanterar kantfall. Att välja fel läge ger utdata som ser korrekt ut men misslyckas vid tolkningstillfället.

Kodexempel

Exempel för att escapa och unescapa strängar i JavaScript, Python, Go och på kommandoraden.

// 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

Vanliga frågor