String Escape

String Escaping क्या है?

String escaping वह प्रक्रिया है जिसमें स्ट्रिंग लिटरल के अंदर विशेष अर्थ रखने वाले वर्णों से पहले एक backslash (या अन्य मार्कर) डाला जाता है। जब कोई प्रोग्रामिंग लैंग्वेज पार्सर को double-quoted स्ट्रिंग के अंदर एक double quote मिलता है, तो वह इसे स्ट्रिंग का अंत मान लेता है। quote को backslash से escape करना — \" लिखना " की जगह — पार्सर को बताता है कि इसे एक literal वर्ण के रूप में माना जाए, न कि delimiter के रूप में। हर वह भाषा जो string literals का उपयोग करती है, उसके escape नियम होते हैं, हालाँकि सटीक sequences अलग-अलग होती हैं।

सबसे सामान्य escape sequences whitespace और control characters को represent करती हैं जो सीधे source code में नहीं आ सकतीं। एक newline \n बन जाता है, एक tab \t बन जाता है, और एक literal backslash \\ बन जाता है। ये परंपराएँ C प्रोग्रामिंग लैंग्वेज (ISO/IEC 9899) से आती हैं और JavaScript (ECMA-262), Python, Java, Go और Rust द्वारा अपनाई गई हैं। JSON (RFC 8259) समान सिंटैक्स का उपयोग करता है लेकिन sequences का एक छोटा सेट समर्थित करता है।

Unescaping (जिसे कभी-कभी "de-escaping" भी कहा जाता है) विपरीत ऑपरेशन है: escape sequences को उनके मूल वर्णों में वापस बदलना। यह log files पढ़ते समय, API responses पार्स करते समय, या ऐसे डेटा को debug करते समय आम है जो double-escaped हो गया हो। हाथ से किए जाने पर दोनों ऑपरेशन थकाऊ होते हैं और इनमें गलतियाँ होना आसान है, इसलिए developers multi-line strings, embedded quotes, या Unicode वर्णों के साथ काम करते समय एक escape/unescape टूल की ओर रुख करते हैं।

Online String Escape टूल का उपयोग क्यों करें?

backslashes को मैन्युअल रूप से जोड़ना या हटाना थकाऊ है और गलती करना आसान है, विशेष रूप से nested quotes या multi-line इनपुट के साथ। एक browser-based string escape टूल REPL सेट अप किए बिना या throwaway scripts लिखे बिना तत्काल परिणाम देता है।

String Escape के उपयोग के मामले

Escape Sequence Reference

नीचे दी गई तालिका सामान्य escape sequences और यह सूचीबद्ध करती है कि वे JavaScript, Python और JSON में समर्थित हैं या नहीं। तीनों भाषाएँ core set (newline, tab, backslash, double quote) साझा करती हैं, लेकिन single quotes, hex escapes और extended Unicode notation में भिन्न होती हैं।

JavaScript बनाम Python बनाम JSON Escaping

हालाँकि ये तीन फ़ॉर्मेट समान backslash-based सिंटैक्स साझा करते हैं, ये इस बात में भिन्न होते हैं कि कौन सी sequences वैध हैं और edge cases को कैसे संभालते हैं। गलत मोड चुनने पर ऐसा आउटपुट मिलता है जो सही दिखता है लेकिन parse time पर fail हो जाता है।

कोड उदाहरण

JavaScript, Python, Go और command line में strings को escape और unescape करने के उदाहरण।

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

अक्सर पूछे जाने वाले प्रश्न