เครื่องมือสำหรับนักพัฒนา · JSON ฟอร์แมตเตอร์ & เครื่องมือตรวจสอบความถูกต้อง
JSON สตริง Escape อธิบาย: \n, \uXXXX และอักขระควบคุม
· มันทำงานอย่างไร
json นักพัฒนาเวิร์กโฟลว์ การตรวจสอบ
การขึ้นบรรทัดใหม่แบบดิบภายในสตริง JSON ไม่ถูกต้อง และแท็บก็เช่นกัน โพสต์นี้ครอบคลุมลำดับการหลีกเลี่ยงทั้งแปดลำดับ วิธีการทำงานของ \u การหลีกเลี่ยงและการจับคู่ตัวแทน และเหตุใดย่อหน้าที่วางอาจทำให้ไฟล์ทั้งหมดเป็นโมฆะ
ย่อหน้าที่ทำลายเพย์โหลด
ย่อหน้าที่ทำลายเพย์โหลด - การวางตัวแบ่งบรรทัดที่มองเห็นได้ลงในคำอธิบายที่ยกมาจะแทรกอักขระควบคุมลงในสตริง JSON โดยตรง บรรทัดแรกดูเหมือนเสร็จสมบูรณ์แล้ว แต่เครื่องหมายคำพูดเปิดยังคงต้องการเนื้อหาสตริงหรือเครื่องหมายคำพูดปิด เมื่อ parser ไปถึงการป้อนบรรทัดแบบ raw parser จะหยุดอยู่ตรงนั้นเนื่องจากสตริง JSON ไม่สามารถขยายบรรทัดฟิสิคัลในลักษณะนั้นได้ ข้อความต้องมีอักขระหลีก `\n` สองตัว ทุกที่ที่ค่าที่ถอดรหัสจำเป็นต้องขึ้นบรรทัดใหม่
แท็บที่คัดลอกมาจากเอกสารหรือสเปรดชีตทำให้เกิดความล้มเหลวในระดับเดียวกัน แม้ว่าตัวแก้ไขอาจแสดงการเว้นวรรคที่ไม่เป็นอันตรายก็ตาม แทนที่แท็บตัวอักษรด้วย `\t` การขึ้นบรรทัดใหม่ด้วย `\r` และการควบคุมที่ต้องห้ามอื่นๆ ด้วยการหลีกชื่อหรือ Unicode
การหลบหนีทั้งแปดครั้งที่ JSON อนุญาต
การหลีกเลี่ยงทั้งแปดแบบ JSON อนุญาต - หลังจากแบ็กสแลช รูปแบบย่อคือ `"`, `\\`, `\/`, `\b`, `\f`, `\n`, `\r` และ `\t` พวกมันแสดงถึงเครื่องหมายคำพูด แบ็กสแลช สแลช แบ็คสเปซ การป้อนแบบฟอร์ม การป้อนบรรทัด การขึ้นบรรทัดใหม่ และแท็บแนวนอน เครื่องหมายทับอาจปรากฏว่าไม่ได้ใช้ Escape `\/` มีอยู่เพื่อความเข้ากันได้กับบริบทซึ่งครั้งหนึ่งเคยปฏิบัติต่อลำดับสคริปต์ปิดเป็นพิเศษ
ห้ามมีตัวอักษรอื่นตามหลังเครื่องหมายแบ็กสแลช JSON ลำดับที่คุ้นเคยจากภาษาการเขียนโปรแกรม เช่น `\v`, `\0`, `\x41` หรือแบ็กสแลชที่ตามด้วยการขึ้นบรรทัดใหม่ทางกายภาพ ไม่ถูกต้องที่นี่ ใช้ `\u` ตามด้วยเลขฐานสิบหกสี่หลักทุกประการเมื่อไม่มีการหลีกเลี่ยงระยะสั้น คำศัพท์คงที่ขนาดเล็กนี้ทำให้สตริง JSON สามารถพกพาได้: ผู้ใช้ไม่จำเป็นต้องใช้ JavaScript, Python หรือกฎการหลีกเฉพาะเชลล์เพื่อกำหนดอักขระที่แสดงด้วยข้อความที่ถูกต้อง
เหตุใดแท็บตัวอักษรจึงไม่ถูกต้อง แต่ é ตามตัวอักษรก็ใช้ได้
เหตุใดแท็บตัวอักษรจึงไม่ถูกต้อง แต่ é ตามตัวอักษรก็ใช้ได้ — JSON ห้ามจุดโค้ดที่ไม่ใช้ Escape จาก U+0000 ถึง U+001F ภายในสตริง ช่วงดังกล่าวประกอบด้วยแท็บ บรรทัดใหม่ และตัวควบคุมอื่นๆ ซึ่งเอฟเฟ็กต์ที่มองไม่เห็นสามารถรบกวนการจัดเฟรมหรือการแสดงผลได้ ตัวอักษร `é` คือ U+00E9 ซึ่งอยู่นอกช่วงการควบคุม ดังนั้น UTF-8 JSON อาจรวมไว้ระหว่างเครื่องหมายคำพูดโดยตรง เช่นเดียวกับสคริปต์ สัญลักษณ์ และอีโมจิส่วนใหญ่
ดังนั้นการ Escape Unicode ธรรมดาจึงเป็นทางเลือก ไม่ใช่ข้อกำหนดด้านความสะอาด `"café"` และ `"caf\u00e9"` ถอดรหัสเป็นลำดับอักขระเดียวกัน โดยทั่วไปแล้วข้อความโดยตรงมักจะอ่านได้ง่ายกว่าในขณะที่การหลีกสามารถช่วยให้ ASCII ส่งผ่านเท่านั้นหรือทำให้มองเห็นหน่วยโค้ดเฉพาะได้ อักขระควบคุมแตกต่างกัน: จำเป็นต้องมีการยกเว้น
\uXXXX Escape ทำงานอย่างไร
วิธีการทำงานของ `\uXXXX` Escape — `u` จะต้องตามด้วยเลขฐานสิบหกสี่หลักพอดี โดยใช้ 0–9 หรือ A–F ในทั้งสองกรณี `\u00E9` แสดงถึงหน่วยโค้ด UTF-16 สำหรับ `é` และ `\u000A` แสดงถึงการป้อนบรรทัด จำนวนหลักที่น้อยลง วงเล็บปีกกา เช่น `\u{1F600}` หรือตัวอักษรที่ไม่ใช่เลขฐานสิบหกจะทำให้ JSON ไม่ถูกต้อง แม้ว่าภาษาการเขียนโปรแกรมอื่นจะยอมรับสัญลักษณ์นั้นก็ตาม
อักขระที่อยู่เหนือ U+FFFF จะแสดงในรูปแบบการหลีกเลี่ยงนี้เป็นคู่ตัวแทน อีโมจิ 😀 สามารถเขียนเป็น `\uD83D\uDE00`: ตัวแทนสูงและต่ำรวมกันหลังจากแยกวิเคราะห์เป็นค่าสเกลาร์ Unicode หนึ่งค่า JSON ไวยากรณ์สามารถดำเนินการเลี่ยงตัวแทนที่ไม่ได้จับคู่ได้ แต่ตัวเข้ารหัสและแอปพลิเคชันดาวน์สตรีมอาจปฏิเสธหรือแทนที่เนื่องจากไม่ได้ระบุอักขระ Unicode ที่สมบูรณ์
ตัวอย่างการทำงาน: การหลีกเลี่ยงเส้นทาง Windows และตัวอย่างข้อมูล HTML
ตัวอย่างการทำงาน: การหลีกเลี่ยงเส้นทาง Windows และตัวอย่างข้อมูล HTML — เส้นทางที่ต้องการ `C:\Temp\report.txt` ต้องการให้แต่ละแบ็กสแลชเพิ่มเป็นสองเท่าใน JSON แหล่งที่มา: `"C:\\Temp\\report.txt"` หากไม่มีการเพิ่มขึ้นเป็นสองเท่า `\T` จะเป็น Escape ที่ไม่ถูกต้อง และลำดับ เช่น `\r` หรือ `\t` สามารถกลายเป็นอักขระควบคุมโดยไม่ต้องแจ้งให้ทราบ แทนที่จะเป็นตัวคั่นพาธ สร้าง JSON จากค่าที่ต้องการ ไม่ใช่โดยการเดาว่าเครื่องหมายทับที่แสดงใดเป็นของภาษาภายนอกอยู่แล้ว
ส่วน HTML เช่น `<a title="Report">Open</a>` อาจเก็บวงเล็บเหลี่ยมและเครื่องหมายทับตามตัวอักษร แต่เครื่องหมายคำพูดของแอตทริบิวต์จะต้องกลายเป็น `\"` ภายในสตริง JSON หากขึ้นบรรทัดใหม่แยกสองแท็ก ให้เข้ารหัสเป็น `\n` สมาชิกผลลัพธ์ JSON สามารถตรวจสอบและแยกวิเคราะห์กลับไปเป็นข้อความ HTML ต้นฉบับได้
ในกรณีที่มีการหลบหนีเพิ่มขึ้นเป็นสองเท่า
โดยที่ค่า Escape จะเพิ่มเป็นสองเท่า — ทุกไวยากรณ์ข้อความที่ปิดล้อมจะได้รับโอกาสในการตีความแบ็กสแลชเอง เอกสาร JSON ที่มีสตริงถอดรหัส `line1\nline2` จะต้องหลีกเลี่ยงเครื่องหมายแบ็กสแลชนั้น โดยสร้าง `"line1\\nline2"` หากข้อความ JSON นั้นถูกจัดเก็บเป็นสตริง JSON เครื่องหมายคำพูดและแบ็กสแลชทั้งสองจะต้องมีการ Escape อีกชั้นหนึ่ง ความยุ่งเหยิงที่ชัดเจนบันทึกการนำเสนอหลายรายการ ไม่ใช่รูปแบบขยายพิเศษของ JSON
เชลล์และตัวอักษรภาษาโปรแกรมจะเพิ่มกฎการเสนอราคาของตัวเองก่อนที่พาร์เซอร์ JSON จะเห็นอาร์กิวเมนต์ วินิจฉัยจากภายในสู่ภายนอก: เขียนค่าถอดรหัสที่แน่นอนก่อน เข้ารหัสเป็น JSON หนึ่งครั้ง จากนั้นเข้ารหัสข้อความ JSON ให้สมบูรณ์สำหรับเชลล์หรือภาษาต้นฉบับโดยรอบ ที่แต่ละขอบเขต ให้ตรวจสอบว่าไบต์หรืออักขระใดที่ parser ถัดไปได้รับจริง
สิ่งนี้ไม่ครอบคลุมถึง
สิ่งนี้ไม่ครอบคลุม — HTML เอนทิตี เช่น `"` และ URL การเข้ารหัสเปอร์เซ็นต์ เช่น `%20` เป็นการแปลงที่แยกกันสำหรับบริบททางวากยสัมพันธ์ที่แยกจากกัน ตัวแยกวิเคราะห์ JSON ไม่ได้ถอดรหัสรูปแบบใดรูปแบบหนึ่ง สตริง `"""` มีอักขระตัวอักษรหกตัวหลังการแยกวิเคราะห์ ไม่ใช่เครื่องหมายคำพูด และ `"%20"` มีเครื่องหมายเปอร์เซ็นต์ตามด้วยตัวเลขสองหลัก ไม่ใช่ช่องว่าง ใช้การเข้ารหัสเหล่านั้นเฉพาะเมื่อข้อมูลข้ามไปยังคอมโพเนนต์ HTML หรือ URL
การสนทนานี้ไม่ได้แทนที่การเข้ารหัสเอาต์พุตด้วย JSON ที่ถูกต้องที่ได้รับจากแหล่งที่ไม่น่าเชื่อถือยังคงมี HTML ข้อความที่เหมือนสคริปต์หรือลำดับการควบคุมเทอร์มินัลเป็นข้อมูลสตริงธรรมดา แอปพลิเคชันที่แสดงผลหรือดำเนินการคำสั่งในภายหลังจะต้องจัดการปลายทางนั้นอย่างปลอดภัย JSON การหลบหนีปกป้องโครงสร้าง JSON; ไม่ใช่การฆ่าเชื้อแบบสากล
ประเด็นสำคัญ: หลีกหนีจากสิ่งที่ไวยากรณ์ห้าม ไม่มีอะไรเพิ่มเติม
ประเด็นสำคัญ: หลีกหนีจากสิ่งที่ไวยากรณ์ห้าม ไม่มีอะไรมากไปกว่านี้ - เครื่องหมายคำพูดคู่ แบ็กสแลช และจุดโค้ดที่ต่ำกว่า U+0020 ต้องการความสนใจภายในสตริง JSON Unicode ธรรมดายังคงสามารถอ่านได้ ในขณะที่ `\uXXXX` ให้ทางเลือกสี่หลักที่แน่นอน และคู่ตัวแทนแทนอักขระที่อยู่เหนือ U+FFFF การวินิจฉัยตำแหน่งที่ดูเหมือนจะว่างเปล่ามักจะระบุการขึ้นบรรทัดใหม่ แท็บ หรืออักขระควบคุมอื่นๆ ที่ต้องแทนที่ด้วยการหลีกข้อความ
นับเลเยอร์การเข้ารหัสแทนการนับเครื่องหมายทับด้วยการมองเห็น เริ่มจากค่าที่แอปพลิเคชันควรได้รับ เข้ารหัสหนึ่งครั้งสำหรับ JSON จากนั้นเสนอราคาเอกสารผลลัพธ์สำหรับเชลล์ภายนอก ไฟล์ต้นฉบับ หรือสตริง JSON ตัวที่สองเท่านั้น ตรวจสอบความถูกต้องของข้อความที่นำเสนอต่อ JSON parser และเมื่อความถูกต้องมีความสำคัญ ให้ตรวจสอบสตริงที่ถอดรหัสในภายหลัง