เครื่องมือสำหรับนักพัฒนา · JSON ฟอร์แมตเตอร์ & เครื่องมือตรวจสอบความถูกต้อง
JavaScript ตัวอักษรวัตถุเทียบกับ JSON: เหตุใดเครื่องหมายคำพูดเดี่ยวจึงไม่ผ่านการตรวจสอบ
· มันทำงานอย่างไร
json นักพัฒนาเวิร์กโฟลว์ การตรวจสอบ
วัตถุที่พิมพ์โดยคอนโซล JavaScript ดูเหมือน JSON แต่โดยปกติจะไม่ใช่ โพสต์นี้แสดงรายการความแตกต่างที่แน่นอน (เครื่องหมายคำพูด คีย์ที่ไม่มีเครื่องหมายคำพูด ไม่ได้กำหนด ฟังก์ชัน) และแสดงให้เห็นว่าแต่ละรายการเดินทางไปที่เครื่องมือตรวจสอบความถูกต้อง
มันออกมาจากคอนโซล แล้วทำไมมันถึงไม่ถูกต้อง?
มันออกมาจากคอนโซล แล้วทำไมมันถึงไม่ถูกต้อง? — คอนโซลนักพัฒนาซอฟต์แวร์แสดงค่า JavaScript เป็นข้อความที่เหมือนต้นฉบับ JavaScript ไม่ใช่เป็นอนุกรม JSON ที่รับประกัน วัตถุที่คัดลอกอาจมีชื่อคุณสมบัติเปล่า สตริงเครื่องหมายคำพูดเดี่ยว `undefined` หรือคำอธิบายประกอบเฉพาะเบราว์เซอร์ ทั้งหมดนี้สามารถเข้าใจได้โดยกลไก JavaScript หรือโปรแกรมอ่านที่เป็นมนุษย์ ในขณะที่ล้มเหลวในทันทีในไฟล์ `.json` ซึ่งมีไวยากรณ์ที่เล็กลงโดยเจตนาและเป็นอิสระจากโค้ดที่ปฏิบัติการได้
พิจารณา `{name: "Ada", active: true, missing: undefined}` วงเล็บปีกกา ทวิภาค และบูลีนมีลักษณะคล้ายกับ JSON แต่คีย์เปล่าอันแรกละเมิดกฎของสมาชิกอ็อบเจ็กต์แล้ว และ `undefined` จะล้มเหลวในภายหลัง ToolAcre รายงานอักขระหรือค่าตัวแรกที่ไม่รองรับด้วยบรรทัดและคอลัมน์ ดังนั้นการแปลงควรทำตามลำดับดีที่สุด
สตริงต้องใช้เครื่องหมายคำพูดคู่
สตริงต้องใช้เครื่องหมายคำพูดคู่ — JSON กำหนดสตริงเป็นอักขระที่ล้อมรอบด้วย `"` โดยมีเครื่องหมายแบ็กสแลชเป็นหลีกตามที่จำเป็น เครื่องหมายคำพูดเดี่ยวไม่มีบทบาทเป็นตัวคั่นสตริง เมื่อเครื่องมือตรวจสอบความถูกต้องตรงตาม `'Ada'` จะไม่ขึ้นต้นสตริงแล้วจึงคัดค้านเนื้อหา มันปฏิเสธเครื่องหมายอะพอสทรอฟีเปิดเอง สิ่งนี้ใช้กับชื่อคุณสมบัติและค่าสตริงอย่างเท่าเทียมกัน แม้ว่า JavaScript จะอนุญาตให้ใช้รูปแบบเครื่องหมายคำพูดแบบใดแบบหนึ่งสำหรับตัวอักษรของตัวเองก็ตาม
การแปลงเครื่องหมายคำพูดต้องได้รับการดูแลมากกว่าการแทนที่เครื่องหมายอะพอสทรอฟีทุกตัวทั่วโลก เครื่องหมายอะพอสทรอฟีภายในข้อความ เช่น `Ada's profile` เป็นเนื้อหาธรรมดาเมื่อค่ามีเครื่องหมายคำพูดคู่ ในขณะที่เครื่องหมายคำพูดคู่ที่มีอยู่ในเนื้อหานั้นจะต้องเป็นหลีก แบบฟอร์ม JSON ที่ถูกต้องคือ `"Ada's "profile""`
คีย์จะต้องเป็นสตริงที่มีเครื่องหมายคำพูด
คีย์จะต้องเป็นสตริงเครื่องหมายคำพูด — JavaScript ตัวอักษรวัตถุอนุญาตให้ใช้ชื่อสไตล์ตัวระบุ เช่น `{name: 1}` และชื่อที่คำนวณ เช่น `{[expression]: 1}` JSON ไม่อนุญาตให้ใช้ชวเลข หลังจากเครื่องหมายปีกกาเปิดหรือเครื่องหมายจุลภาค สมาชิกถัดไปต้องขึ้นต้นด้วยสตริงที่มีเครื่องหมายคำพูดคู่ ตามด้วยเครื่องหมายโคลอน การแสดงที่ถูกต้องคือ `{"name": 1}` เครื่องมือตรวจสอบที่ชี้ไปที่ `n` กำลังระบุตำแหน่งที่แน่นอนที่ต้องการใบเสนอราคา
การอ้างอิงทุกคีย์ยังช่วยขจัดความคลุมเครือบริเวณช่องว่าง ยัติภังค์ และคำสงวนอีกด้วย JavaScript อาจต้องใช้ไวยากรณ์แหล่งที่มาที่แตกต่างกันสำหรับกรณีเหล่านั้น แต่ JSON ใช้กฎที่สอดคล้องกันเพียงกฎเดียว: `"display-name"`, `"first name"` และ `"default"` ล้วนแต่เป็นชื่อสมาชิกธรรมดา ปุ่มที่มีลักษณะเป็นตัวเลขก็เป็นสตริงเช่นกัน
ค่า JSON ไม่มี
ค่า JSON ไม่มี — คำศัพท์ค่าของมันคือ object, array, string, number, `true`, `false` และ `null` ไม่มี `undefined`, `NaN`, `Infinity`, ฟังก์ชัน, นิพจน์ทั่วไป, BigInt หรือ Date literal ความคิดเห็นขาดหายไปจากไวยากรณ์ และตัวเลขไม่สามารถใช้เลขฐานสิบหก ไบนารี เครื่องหมายบวกนำหน้า หรือตัวคั่นตัวเลข JavaScript โครงสร้างที่ยืมมาแต่ละรายการจะมีอักขระที่ไม่สามารถเริ่มต้นหรือดำเนินการต่อด้วยค่า JSON ที่ถูกต้องได้ในที่สุด
การแปลงต้องใช้การตัดสินใจข้อมูลมากกว่าเคล็ดลับการสะกดคำ แทนที่ `undefined` ด้วย `null` เฉพาะในกรณีที่ค่าว่างที่ชัดเจนตรงกับสัญญาแอปพลิเคชัน มิฉะนั้นให้ลบสมาชิกออกหรือระบุมูลค่าที่แท้จริง เข้ารหัสวันที่เป็นสตริงที่ตกลงกัน ซึ่งมักจะเป็น ISO 8601 เป็นตัวแทนของตัวเลขที่ไม่สิ้นสุดตามการรับ API แทนที่จะประดิษฐ์โทเค็น JSON
ตัวอย่างการทำงาน: การแปลงดัมพ์คอนโซลให้เป็น JSON ที่ถูกต้อง
ตัวอย่างการทำงาน: การแปลงดัมพ์ของคอนโซลให้เป็น JSON ที่ถูกต้อง — เริ่มต้นด้วย `{name: 'Ada', active: true, score: NaN, updated: new Date()}` อ้าง `name`, `active`, `score` และ `updated` ด้วยเครื่องหมายคำพูดคู่ เปลี่ยนค่าชื่อเป็นสตริงที่มีเครื่องหมายคำพูดคู่ ตัดสินใจว่าคะแนนที่ไม่พร้อมใช้งานควรเป็น `null` และแทนที่นิพจน์ Constructor ด้วยสตริงการประทับเวลาจริงที่ตั้งใจจะสร้าง ขณะนี้เอกสารมีเพียงสมาชิกและค่า JSON เท่านั้น
รูปร่างที่เสร็จแล้วอาจเป็น `{"name":"Ada","active":true,"score":null,"updated":"2026-03-21T10:00:00Z"}` ตรวจสอบหลังจากการซ่อมแซมแต่ละประเภท เนื่องจากข้อผิดพลาดแรกสามารถซ่อนได้ในภายหลัง JavaScript-ไวยากรณ์เท่านั้น การจัดรูปแบบผลลัพธ์ที่ยอมรับจะเปิดเผยโครงสร้างของผลลัพธ์โดยไม่ต้องทำการแปลงใดๆ เพิ่มเติม
Reverse Trap — ถูกต้อง JSON ที่ JavaScript จะอ่านแตกต่างออกไป เช่น จำนวนเต็มขนาดใหญ่มากและคีย์ __proto__
Reverse Trap — JSON ที่ถูกต้องยังคงสามารถรับ JavaScript พฤติกรรมหรือข้อจำกัดเฉพาะได้หลังการแยกวิเคราะห์ ตัวเลข JSON ไม่มีขีดจำกัดความแม่นยำในตัวในไวยากรณ์ แต่ JSON.parse สร้างค่า JavaScript ค่าตัวเลข จึงสามารถปัดเศษจำนวนเต็มที่เกินช่วงปลอดภัยได้ หากทุกหลักมีความสำคัญ ให้เข้ารหัสตัวระบุเป็นสตริง หรือใช้ตัวแยกวิเคราะห์และประเภทข้อมูลที่ออกแบบมาเพื่อรักษาตัวเลขที่มีความแม่นยำตามอำเภอใจ แทนที่จะเชื่อถือการตรวจสอบไวยากรณ์ที่ประสบความสำเร็จ
ชื่อสมาชิก `"__proto__"` ก็ถูกต้องเช่นกัน JSON และ JSON.parse จะสร้างเป็นคุณสมบัติข้อมูลของตัวเอง ปัญหาอาจเริ่มได้ในภายหลังหากโค้ดแอปพลิเคชันคัดลอกคุณสมบัติที่แยกวิเคราะห์ไปยังออบเจ็กต์อื่นที่มีการกำหนดที่ไม่ปลอดภัยหรือพฤติกรรมการผสาน การตรวจสอบความถูกต้องจะพิสูจน์ว่าข้อความเป็นไปตามไวยากรณ์ JSON; มันไม่ได้พิสูจน์ว่าทุกคีย์ปลอดภัยสำหรับผู้บริโภคทุกคน
สิ่งนี้ไม่ครอบคลุมถึง
สิ่งนี้ไม่ครอบคลุมถึง JSON5, JSONC และภาษาการกำหนดค่าที่จงใจยอมรับความคิดเห็น เครื่องหมายจุลภาคต่อท้าย ชื่อที่ไม่มีเครื่องหมายคำพูด หรือสตริงที่มีเครื่องหมายคำพูดเดี่ยว รูปแบบเหล่านั้นแก้ปัญหาการเขียนที่แตกต่างกัน และต้องการตัวแยกวิเคราะห์ที่ใช้ไวยากรณ์ของตนเอง เครื่องมือตรวจสอบความถูกต้อง JSON ที่เข้มงวดไม่ควรตีความใหม่โดยไม่แจ้งให้ทราบ เนื่องจากการยอมรับไวยากรณ์เพิ่มเติมจะทำให้ผลลัพธ์เข้าใจผิดสำหรับ API ข้อมูลเมตาของแพ็คเกจ และปลายทางอื่นๆ ที่ต้องใช้มาตรฐาน JSON อย่างแท้จริง
ความแตกต่างนี้ยังไม่รวมการประเมิน JavaScript ตามอำเภอใจอีกด้วย การเรียกใช้ข้อความที่วางผ่าน `eval` หรือตัวสร้างฟังก์ชันเพียงเพื่อเปลี่ยนวัตถุตามตัวอักษรให้เป็นข้อมูลสามารถดำเนินการ getters การเรียก หรือนิพจน์ที่ไม่เป็นมิตรอื่นๆ หากแหล่งที่มาเชื่อถือได้ JavaScript ภายใต้การควบคุมของคุณ ให้ทำให้ค่าจริงเป็นอนุกรมด้วย JSON.stringify หากแหล่งที่มาเป็นข้อความที่ไม่น่าเชื่อถือ อย่าดำเนินการ
ประเด็นสำคัญ: ตัวอักษรคือรหัส JSON คือข้อมูล
ประเด็นสำคัญ: ตัวอักษรคือโค้ด JSON คือข้อมูล ความคล้ายคลึงกันทางการมองเห็นไม่ได้ทำให้ไวยากรณ์ของพวกมันใช้แทนกันได้ JSON ต้องใช้สตริงที่มีเครื่องหมายคำพูดคู่และชื่อสมาชิก อนุญาตเฉพาะชุดค่าคงที่จำนวนเล็กน้อยเท่านั้น และไม่มีความคิดเห็นหรือนิพจน์ที่สามารถเรียกใช้งานได้ การวินิจฉัยแบบบรรทัดและคอลัมน์จะทำเครื่องหมายที่แรกที่แหล่งที่มาที่คัดลอกออกจากไวยากรณ์นั้น การซ่อมแซมจุดนั้นและการตรวจสอบความถูกต้องอีกครั้งมีความน่าเชื่อถือมากกว่าการใช้การค้นหาและแทนที่แบบกว้างๆ กับดัมพ์ของคอนโซล
เมื่อคุณควบคุมค่า JavaScript ให้สร้าง JSON ด้วย JSON.stringify แทนที่จะคัดลอกการแสดงคอนโซล เมื่อคุณได้รับข้อความ ให้แยกวิเคราะห์โดยใช้ parser สำหรับรูปแบบที่ประกาศไว้เท่านั้น และอย่าดำเนินการเป็นทางลัด การตรวจสอบความถูกต้อง JSON ที่ประสบความสำเร็จจะสร้างไวยากรณ์ ไม่ใช่ความแม่นยำเชิงตัวเลข ความสอดคล้องของสคีมา หรือการจัดการคุณสมบัติดาวน์สตรีมที่ปลอดภัย