ToolDeck

เอสเคปสตริง

เอสเคปและถอดเอสเคปสตริงสำหรับ JavaScript, Python และ JSON

ลองตัวอย่าง

อินพุต

เอาต์พุต

ประมวลผลในเครื่อง · ปลอดภัยในการวางข้อมูลลับ
ผลลัพธ์จะแสดงที่นี่…
โหมด:

การเอสเคปสตริงคืออะไร?

การเอสเคปสตริง (String Escaping) คือกระบวนการแทรกแบ็กสแลช (หรืออักขระพิเศษอื่น) ไว้หน้าอักขระที่มีความหมายพิเศษภายในสตริงลิเทอรัล เมื่อตัวแปลภาษาโปรแกรมพบเครื่องหมายอัญประกาศคู่ภายในสตริงที่ล้อมด้วยอัญประกาศคู่ ตัวแปลจะตีความว่าเป็นจุดสิ้นสุดของสตริง การเอสเคปอัญประกาศด้วยแบ็กสแลช — เขียนเป็น \" แทน " — บอกให้ตัวแปลถือว่ามันเป็นอักขระธรรมดา ไม่ใช่ตัวคั่น ทุกภาษาที่ใช้สตริงลิเทอรัลมีกฎการเอสเคป แม้ลำดับที่ใช้จะแตกต่างกัน

ลำดับเอสเคปที่พบบ่อยที่สุดใช้แทนอักขระช่องว่างและอักขระควบคุมที่ไม่สามารถปรากฏในซอร์สโค้ดโดยตรง ตัวขึ้นบรรทัดใหม่จะกลายเป็น \n, แท็บกลายเป็น \t และแบ็กสแลชตัวจริงกลายเป็น \\. แบบแผนเหล่านี้สืบทอดมาจากภาษา C (ISO/IEC 9899) และถูกนำมาใช้ใน JavaScript (ECMA-262), Python, Java, Go และ Rust ส่วน JSON (RFC 8259) ใช้ไวยากรณ์เดียวกันแต่รองรับลำดับเอสเคปในจำนวนที่น้อยกว่า

การถอดเอสเคป (Unescaping หรือ de-escaping) คือการดำเนินการแบบย้อนกลับ: แปลงลำดับเอสเคปกลับเป็นอักขระเดิม ซึ่งมักพบเมื่ออ่านไฟล์ล็อก, แปลงผลตอบกลับ API หรือดีบักข้อมูลที่ถูกเอสเคปซ้ำซ้อน ทั้งสองการดำเนินการเป็นงานซ้ำซากและเกิดข้อผิดพลาดได้ง่ายเมื่อทำเอง ซึ่งเป็นเหตุผลที่นักพัฒนาต้องการเครื่องมือเอสเคป/ถอดเอสเคปเมื่อทำงานกับสตริงหลายบรรทัด, อัญประกาศซ้อน หรืออักขระ Unicode

ทำไมถึงใช้เครื่องมือเอสเคปสตริงออนไลน์?

การเพิ่มหรือลบแบ็กสแลชด้วยมือเป็นงานที่น่าเบื่อและเกิดข้อผิดพลาดได้ง่าย โดยเฉพาะเมื่อมีอัญประกาศซ้อนหรืออินพุตหลายบรรทัด เครื่องมือเอสเคปสตริงบนเบราว์เซอร์ให้ผลลัพธ์ทันทีโดยไม่ต้องตั้งค่า REPL หรือเขียนสคริปต์ชั่วคราว

แปลงได้ทันที
วางข้อความแล้วรับผลลัพธ์ที่เอสเคปหรือถอดเอสเคปแล้วทันที ไม่จำเป็นต้องเปิดเทอร์มินัล, เริ่ม REPL หรือเขียนสคริปต์แบบครั้งเดียว
🔀
สลับระหว่างรูปแบบต่างๆ
สลับระหว่างโหมดเอสเคปของ JavaScript, Python และ JSON แต่ละภาษาจัดการอัญประกาศเดี่ยว, Unicode และอักขระควบคุมแตกต่างกัน — เครื่องมือจะใช้กฎที่ถูกต้องโดยอัตโนมัติ
🔒
ประมวลผลโดยให้ความสำคัญกับความเป็นส่วนตัว
การเอสเคปและถอดเอสเคปทั้งหมดเกิดขึ้นในเบราว์เซอร์ของคุณโดยใช้ JavaScript สตริงของคุณจะไม่ถูกส่งไปยังเซิร์ฟเวอร์ ซึ่งสำคัญเมื่อคุณทำงานกับ API keys, tokens หรือข้อมูลผู้ใช้
📋
ไม่ต้องล็อกอินหรือติดตั้ง
เปิดหน้าเว็บแล้วเริ่มวางข้อความได้เลย ไม่มีบัญชีที่ต้องสร้าง, ไม่มีส่วนขยายที่ต้องติดตั้ง และไม่มีหน้าต่างขอความยินยอมคุกกี้ขวางการใช้งาน

กรณีการใช้งานเอสเคปสตริง

การพัฒนา Frontend
เอสเคปเนื้อหาที่ผู้ใช้สร้างขึ้นก่อนนำไปใส่ใน HTML attributes, inline scripts หรือ template literals ป้องกันมาร์กอัปที่เสียหายและช่องโหว่ XSS จากอัญประกาศหรือวงเล็บมุมที่ไม่ได้เอสเคป
การเชื่อมต่อ API ฝั่ง Backend
สร้าง JSON request body ที่มีสตริงซึ่งมีตัวขึ้นบรรทัดใหม่, แท็บ หรืออัญประกาศ การเอสเคปที่ถูกต้องป้องกัน JSON ที่ผิดรูปแบบซึ่งจะทำให้เกิดข้อผิดพลาด 400 จาก API ที่รับข้อมูล
DevOps และการกำหนดค่า
เขียนสตริงที่เอสเคปแล้วสำหรับไฟล์ JSON config, YAML heredoc หรือตัวแปรสภาพแวดล้อม แบ็กสแลชที่วางผิดตำแหน่งใน Dockerfile ENV หรือ Kubernetes ConfigMap อาจทำให้การ deploy ล้มเหลวได้
QA และข้อมูลทดสอบ
สร้างสตริงทดสอบที่มีอักขระควบคุมซ่อนอยู่, ลำดับ Unicode และอัญประกาศซ้อน สตริง edge case เหล่านี้จำเป็นต้องใช้เพื่อตรวจสอบว่า parser และ serializer จัดการอักขระพิเศษได้ถูกต้อง
วิศวกรรมข้อมูล
ทำความสะอาดข้อมูลที่ถูกเอสเคปซ้ำจาก CSV exports, log aggregator หรือ database dump ฟิลด์ที่ผ่านชั้น serialization หลายชั้นมักสะสมแบ็กสแลชพิเศษที่ต้องถูกลบออก
การเรียนรู้และการดีบัก
ตรวจสอบว่าภาษาต่างๆ แสดงสตริงเดียวกันอย่างไร นักศึกษาและนักพัฒนาที่เพิ่งเริ่มใช้ภาษาสามารถเปรียบเทียบการเอสเคปของ JavaScript, Python และ JSON แบบเคียงข้างกันเพื่อทำความเข้าใจความแตกต่าง

ตารางอ้างอิงลำดับเอสเคป

ตารางด้านล่างแสดงลำดับเอสเคปทั่วไปและการรองรับใน JavaScript, Python และ JSON ทั้งสามภาษาใช้ชุดหลักร่วมกัน (ขึ้นบรรทัดใหม่, แท็บ, แบ็กสแลช, อัญประกาศคู่) แต่แตกต่างกันในอัญประกาศเดี่ยว, hex escapes และ Unicode notation แบบขยาย

ลำดับความหมายJavaScriptPythonJSON
\nNewline (LF)YesYesYes
\rCarriage returnYesYesYes
\tTabYesYesYes
\\BackslashYesYesYes
\"Double quoteYesYesYes
\'Single quoteYesYesNo
\bBackspaceYesYesYes
\fForm feedYesYesYes
\vVertical tabYesYesNo
\0Null characterYesYesNo
\xNNHex byteYesYesNo
\uNNNNUnicode (BMP)YesYesYes
\u{N..}Unicode (full)YesNoNo

เปรียบเทียบการเอสเคปของ JavaScript vs Python vs JSON

แม้ทั้งสามรูปแบบจะใช้ไวยากรณ์แบบแบ็กสแลชเหมือนกัน แต่แตกต่างกันในลำดับที่ถูกต้องและการจัดการ edge case การเลือกโหมดผิดจะให้ผลลัพธ์ที่ดูถูกต้องแต่จะล้มเหลวเมื่อแปลง

JavaScript
รองรับ \x hex escapes, \u{...} สำหรับ Unicode ทั้งหมด (เกิน BMP), \v สำหรับ vertical tab และ \0 สำหรับ null ทั้งอัญประกาศเดี่ยวและคู่สามารถเอสเคปได้ Template literals (backticks) หลีกเลี่ยงความจำเป็นในการเอสเคปส่วนใหญ่
Python
ลำดับหลักเหมือนกับ JavaScript บวกกับ \x hex escapes และ \N{name} สำหรับอักขระ Unicode ที่มีชื่อ Raw strings (r"...") ปิดการประมวลผล escape ทั้งหมด ทั้งอัญประกาศเดี่ยวและคู่สามารถเอสเคปได้
JSON
รูปแบบที่เข้มงวดที่สุด มีเพียง \" (อัญประกาศคู่), \\, \/, \n, \r, \t, \b, \f และ \uNNNN เท่านั้นที่ถูกต้อง ไม่มีการเอสเคปอัญประกาศเดี่ยว (JSON strings ใช้อัญประกาศคู่เสมอ) ไม่มี hex escapes, ไม่มี \v, ไม่มี \0 อักขระควบคุมใดๆ (U+0000 ถึง U+001F) ต้องใช้ notation แบบ \uNNNN

ตัวอย่างโค้ด

ตัวอย่างการเอสเคปและถอดเอสเคปสตริงใน JavaScript, Python, Go และ command line

JavaScript
// 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\\)"
Python
# 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"
Go
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\""
}
CLI (Bash)
# 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

คำถามที่พบบ่อย

ความแตกต่างระหว่างการเอสเคปและการเข้ารหัสคืออะไร?
การเอสเคปเพิ่มแบ็กสแลชหน้าอักขระพิเศษภายในสตริงลิเทอรัลเพื่อให้ตัวแปลภาษาถือว่าเป็นข้อมูล ไม่ใช่ไวยากรณ์ การเข้ารหัสแปลงสตริงทั้งหมดเป็นรูปแบบที่แตกต่างออกไป — เช่น Base64 encoding แปลงไบนารีเป็นข้อความ ASCII และ URL encoding แทนที่อักขระที่ไม่ปลอดภัยด้วยลำดับ percent-hex การเอสเคปรักษาความสามารถในการอ่าน ส่วนการเข้ารหัสเปลี่ยนรูปแบบทั้งหมด
ทำไมสตริงของฉันจึงมีแบ็กสแลชคู่ (\\\\) แทนที่จะเป็นแบ็กสแลชเดี่ยว?
แบ็กสแลชคู่ปรากฏขึ้นเมื่อสตริงถูกเอสเคปสองครั้ง ซึ่งเกิดขึ้นบ่อยเมื่อข้อมูลผ่านชั้น serialization หลายชั้น — เช่น ค่า JSON ที่เก็บอยู่ภายในสตริง JSON อื่น หรือบรรทัด log ที่ถูก JSON-encode ก่อนถูกเขียนลงไฟล์ แก้ไขโดยถอดเอสเคปสตริงทีละชั้นจนถึงเนื้อหาเดิม
ฉันจะเอสเคปสตริงสำหรับ JSON ใน JavaScript ได้อย่างไร?
ใช้ JSON.stringify() มันจะล้อมสตริงด้วยอัญประกาศคู่และเอสเคปอักขระทั้งหมดที่ JSON ต้องการ: แบ็กสแลช, อัญประกาศคู่, ตัวขึ้นบรรทัดใหม่, แท็บ และอักขระควบคุมที่ต่ำกว่า U+0020 หากต้องการเฉพาะเนื้อหาด้านในโดยไม่มีอัญประกาศล้อมรอบ ให้ใช้ JSON.stringify(str).slice(1, -1)
สตริง JSON มีอัญประกาศเดี่ยวได้ไหม?
ไม่ได้ ข้อกำหนด JSON (RFC 8259) กำหนดให้สตริงทั้งหมดใช้อัญประกาศคู่เป็นตัวคั่น อัญประกาศเดี่ยวไม่ใช่ตัวคั่นสตริงที่ถูกต้องใน JSON แม้ parser บางตัวที่ไม่เข้มงวดจะยอมรับ แต่ JSON parser มาตรฐานจะปฏิเสธสตริงที่ล้อมด้วยอัญประกาศเดี่ยว หากสตริงของคุณมีอักขระอัญประกาศเดี่ยว สามารถปรากฏตามปกติภายใน JSON ที่ใช้อัญประกาศคู่ — ไม่จำเป็นต้องเอสเคป
Raw string ใน Python คืออะไร?
Raw string (นำหน้าด้วย r เช่น r"C:\Users\name") บอกให้ Python interpreter ถือว่าแบ็กสแลชเป็นอักขระธรรมดาแทนที่จะเป็นตัวทำเอสเคป มีประโยชน์สำหรับเส้นทางไฟล์ Windows, regular expressions และสตริงที่ควรรักษาแบ็กสแลชไว้ โปรดทราบว่า raw string ไม่สามารถจบด้วยแบ็กสแลชจำนวนคี่ เนื่องจากแบ็กสแลชท้ายจะเอสเคปอัญประกาศปิด
ฉันจะเอสเคปอักขระ Unicode ใน JavaScript ได้อย่างไร?
JavaScript รองรับรูปแบบ Unicode escape สองแบบ ไวยากรณ์ \uNNNN จัดการอักขระใน Basic Multilingual Plane (U+0000 ถึง U+FFFF) เช่น \u00e9 สำหรับ 'e ที่มีเครื่องหมาย acute' สำหรับอักขระนอก BMP (emoji, อักษรหายาก) ใช้ \u{NNNNN} ที่มีตัวเลข hex สูงสุดหกหลัก — เช่น \u{1F600} สำหรับ emoji หน้ายิ้ม รูปแบบ \u{'} ถูกนำเข้ามาใน ES2015
การเอสเคปสตริงเกี่ยวข้องกับความปลอดภัย (XSS, SQL injection) ไหม?
การเอสเคประดับภาษาและการเอสเคปเพื่อความปลอดภัยมีวัตถุประสงค์ต่างกัน แต่แนวคิดเหมือนกัน: ป้องกันไม่ให้อักขระพิเศษถูกตีความเป็นโค้ด สำหรับการป้องกัน XSS ต้องเอสเคป HTML entities (<, >, &) สำหรับ SQL injection ให้ใช้ parameterized queries แทนการเอสเคปด้วยมือ เครื่องมือนี้จัดการเอสเคประดับภาษา (backslash sequences) ไม่ใช่การเอสเคป HTML หรือ SQL