String Escape

What is String Escaping?

String escaping is the process of inserting a backslash (or other marker) before characters that have special meaning inside a string literal. When a programming language parser encounters a double quote inside a double-quoted string, it treats it as the end of the string. Escaping the quote with a backslash — writing \" instead of " — tells the parser to treat it as a literal character, not a delimiter. Every language that uses string literals has escape rules, though the exact sequences differ.

The most common escape sequences map to whitespace and control characters that cannot appear directly in source code. A newline becomes \n, a tab becomes \t, and a literal backslash becomes \\. These conventions trace back to the C programming language (ISO/IEC 9899) and have been adopted by JavaScript (ECMA-262), Python, Java, Go, and Rust. JSON (RFC 8259) uses the same syntax but supports a smaller set of sequences.

Unescaping (sometimes called "de-escaping") is the reverse operation: converting escape sequences back into their original characters. This is common when reading log files, parsing API responses, or debugging data that has been double-escaped. Both operations are mechanical and error-prone when done by hand, which is why developers reach for an escape/unescape tool when working with multi-line strings, embedded quotes, or Unicode characters.

Why Use an Online String Escape Tool?

Manually adding or removing backslashes is tedious and easy to get wrong, especially with nested quotes or multi-line input. A browser-based string escape tool gives you instant results without setting up a REPL or writing throwaway scripts.

String Escape Use Cases

Escape Sequence Reference

The table below lists common escape sequences and whether they are supported in JavaScript, Python, and JSON. All three languages share the core set (newline, tab, backslash, double quote), but diverge on single quotes, hex escapes, and extended Unicode notation.

JavaScript vs Python vs JSON Escaping

While these three formats share the same backslash-based syntax, they differ in which sequences are valid and how they handle edge cases. Picking the wrong mode produces output that looks correct but fails at parse time.

Code Examples

Examples for escaping and unescaping strings in JavaScript, Python, Go, and the command line.

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

Frequently Asked Questions