เครื่องตรวจสอบ JSON

JSON Validation คืออะไร?

JSON (JavaScript Object Notation) เป็นรูปแบบแลกเปลี่ยนข้อมูลที่ได้รับความนิยมอย่างแพร่หลาย น้ำหนักเบา ออกแบบมาให้สามารถอ่านเข้าใจได้ง่ายสำหรับมนุษย์ และง่ายต่อการประมวลผลโดยเครื่องจักร จุดประสงค์หลักคือการแสดงข้อมูลที่มีโครงสร้าง—เช่น อ็อบเจ็กต์, อาร์เรย์, สตริง, ตัวเลข, บูลีน และค่าว่าง—ในรูปแบบที่ไม่ขึ้นกับภาษาใดๆ

การตรวจสอบความถูกต้องของ JSON คือกระบวนการตรวจสอบโดยโปรแกรมว่าเอกสาร JSON นั้นถูกต้องทั้งในแง่ไวยากรณ์และโครงสร้าง ซึ่งรวมถึงการตรวจสอบสองประเด็นหลักดังนี้:

• การตรวจสอบความถูกต้องทางวากยสัมพันธ์: ตรวจสอบให้แน่ใจว่าข้อความดิบเป็นไปตามไวยากรณ์อย่างเป็นทางการตามที่กำหนดไว้ในข้อกำหนด ECMA-404 JSON ตัวแยกวิเคราะห์ (parsers) ในภาษาการเขียนโปรแกรมสมัยใหม่ส่วนใหญ่ (เช่น JSON.parse() ใน JavaScript, json.loads() ใน Python, JSONDecoder ใน Java) จะคาดหวังไวยากรณ์ที่ถูกต้องและจะเกิดข้อผิดพลาดหากข้อมูลนำเข้ามีความผิดปกติ
• การตรวจสอบโครงสร้าง (สคีมา): นอกเหนือจากไวยากรณ์ การตรวจสอบความถูกต้องของสกีมา (schema validation) จะช่วยตรวจสอบว่า ข้อมูล JSON ตรงกับโครงสร้างที่คาดไว้หรือไม่ รวมถึงประเภทข้อมูล คุณสมบัติที่จำเป็น ข้อจำกัดของค่า และโครงสร้างวัตถุ/อาร์เรย์ที่ซ้อนกัน การตรวจสอบความถูกต้องของสกีมามักทำโดยใช้ JSON Schema ซึ่งกำหนดกฎเกณฑ์สำหรับข้อมูลที่ถือว่าถูกต้อง

ทำไมต้องตรวจสอบความถูกต้องของ JSON?

การตรวจสอบความถูกต้องของ JSON เป็นสิ่งสำคัญในทุกกรณีที่ข้อมูลถูกจัดเก็บหรือส่งผ่าน ไม่ว่าจะเป็นการส่งข้อมูล การเก็บบันทึกข้อมูล หรือการสื่อสารระหว่างบริการ เหตุผลสำคัญได้แก่:

• การป้องกันข้อผิดพลาด: ตรวจจับและรายงานข้อผิดพลาดทางไวยากรณ์ (เช่น การลืมหรือขาดเครื่องหมายจุลภาค วงเล็บไม่ตรงกัน ตัวอักษรที่ไม่ถูกต้อง) ตั้งแต่เนิ่นๆ ก่อนที่จะดำเนินการประมวลผลข้อมูล
• ความสมบูรณ์และความปลอดภัยของข้อมูล: ปฏิเสธข้อมูล JSON ที่ผิดรูปแบบหรือมีเจตนาร้าย ช่วยป้องกันการล่มของระบบหลังบ้าน การโจมตีแบบฉีดโค้ด และการทำลายข้อมูล
• ความปลอดภัยของประเภทข้อมูล: บังคับใช้การพิมพ์ชนิดอย่างเข้มงวด—เพื่อให้แน่ใจว่า เช่น ฟิลด์ที่คาดหวังว่าจะเป็นบูลีนจะไม่ถูกส่งเป็นสตริง หรือว่า UUID อีเมล หรือหมายเลข จะต้องเป็นไปตามรูปแบบที่ถูกต้อง
• ความเข้ากันได้ข้ามภาษา: รับประกันว่า JSON ที่สร้างขึ้นในสภาพแวดล้อมหนึ่ง (เช่น Node.js) จะสามารถใช้งานได้อย่างปลอดภัยในสภาพแวดล้อมอื่น (เช่น Python, Go, Java) โดยไม่เกิดข้อผิดพลาดในการแปลงข้อมูล (serialization/deserialization)
• ความสามารถในการบำรุงรักษาและความทนทาน: โครงสร้างข้อมูลที่ผ่านการตรวจสอบช่วยเพิ่มความสามารถในการติดตามและลดความเสี่ยงของข้อผิดพลาดที่ตรวจสอบและแก้ไขได้ยากในไฟล์การกำหนดค่า บันทึก หรือคำขอ/ตอบสนอง API
• ความเป็นส่วนตัวและความปลอดภัย: การตรวจสอบความถูกต้องสามารถทำได้ทั้งหมดในฝั่งลูกค้า (ภายในเบราว์เซอร์) ซึ่งช่วยป้องกันไม่ให้ข้อมูลดิบหรือข้อมูลที่ละเอียดอ่อนถูกส่งออกจากอุปกรณ์ของผู้ใช้เพื่อการตรวจสอบ

ข้อผิดพลาดในการตรวจสอบ JSON ที่พบบ่อย (พร้อมตัวอย่างละเอียด)

คีย์ที่ไม่มีเครื่องหมายคำพูด

คีย์ทั้งหมดในอ็อบเจ็กต์ JSON ต้องเป็นสตริงที่มีเครื่องหมายคำพูดคู่เท่านั้น

{ name: "อลิซ" }

{ "name": "อลิซ" }

รูปแบบข้อมูลหลายชนิดที่คล้ายกับ JSON (เช่น อ็อบเจ็กต์ลิตเทอรัลของ JavaScript) อนุญาตให้ใช้กุญแจที่ไม่ต้องมีเครื่องหมายคำพูดได้ แต่ JSON มาตรฐานจะต้องมีเครื่องหมายคำพูดครอบกุญแจเสมอ

เครื่องหมายคำพูดเดี่ยว

สตริง JSON ต้องใช้เครื่องหมายคำพูดคู่เท่านั้น; ไม่อนุญาตให้ใช้เครื่องหมายคำพูดเดี่ยว

{ 'name': 'บ็อบ' }

{ "name": "บ็อบ" }

การใช้เครื่องหมายอัญประกาศเดี่ยวจะทำให้เกิดข้อผิดพลาดในการวิเคราะห์ไวยากรณ์ในไลบรารี JSON ที่เป็นไปตามมาตรฐานทั้งหมด

การใส่ลูกน้ำท้ายบรรทัด

ไม่ใส่เครื่องหมายจุลภาคหลังรายการสุดท้ายในออบเจ็กต์หรืออาร์เรย์

{
  "a": 1,
  "b": 2,
}

{
  "a": 1,
  "b": 2
}

ลูกน้ำท้ายรายการอาจใช้ได้ใน JavaScript แต่ไม่สามารถใช้ในตัวแยกวิเคราะห์ JSON ที่เข้มงวดได้

การหนีอักขระไม่ถูกต้อง

เครื่องหมายคำพูดและอักขระพิเศษภายในสตริงต้องมีการใส่เครื่องหมายแบ็คสแลชเพื่อหนีอักขระ

{ "quote": "ทอมกล่าวว่า \"สวัสดี\"" }

{ "quote": "ทอมกล่าวว่า \"สวัสดี\"" }

ลำดับการหลีกเลี่ยงอื่น ๆ ได้แก่ \\ สำหรับแบ็คสแลช, \n สำหรับการขึ้นบรรทัดใหม่, และ \t สำหรับแท็บ

ประเภทข้อมูลไม่ถูกต้อง

ไม่ควรใช้สตริงสำหรับตัวเลข, บูลีน หรือค่า null.

{ "enabled": "เปิดใช้งาน", "count": "10" }

{ "เปิดใช้งาน": true, "จำนวน": 10 }

JSON แยกความแตกต่างระหว่างบูลีน ตัวเลข และสตริง—ตรวจสอบให้แน่ใจว่าใช้ประเภทข้อมูลที่ถูกต้องเพื่อความแม่นยำและประสิทธิภาพ

คีย์ที่ไม่ใช่แบบพื้นฐาน

คีย์ของออบเจ็กต์ JSON ต้องเป็นสตริงเสมอ; คุณไม่สามารถใช้ตัวเลข, ค่าบูลีน หรือประเภทอื่น ๆ เป็นคีย์ได้

{ 123: "abc" }

{ "123": "abc" }

คีย์ซ้ำ

แม้ว่าจะได้รับอนุญาตตามสเปคของ JSON แต่การใช้คีย์ซ้ำกันมักเป็นสาเหตุหลักของบั๊กในโปรแกรม

{ "name": "อลิซ", "name": "บ็อบ" }

เครื่องมือวิเคราะห์ข้อมูลส่วนใหญ่จะเก็บเพียงค่าล่าสุด ("Bob") เท่านั้น โดยจะละเว้นค่าก่อนหน้าทั้งหมดอย่างเงียบ ๆ

การใช้งานคอมเมนต์

JSON มาตรฐานไม่อนุญาตให้ใส่คอมเมนต์ แม้ว่าบางโปรแกรมแก้ไขจะรองรับก็ตาม

{
  // ข้อมูลผู้ใช้
  "name": "อลิซ"
}

{
  "name": "อลิซ"
}

การตรวจสอบสคีมา: การบังคับใช้โครงสร้างและประเภทข้อมูล

JSON Schema คือมาตรฐานที่ทรงพลังสำหรับการกำหนดและตรวจสอบโครงสร้างที่คาดหวังของเอกสาร JSON ช่วยให้คุณสามารถระบุได้ว่า:

• ฟิลด์ที่จำเป็น (`required`)
• ประเภทข้อมูล (`type`: ข้อความ, ตัวเลข, บูลีน, วัตถุ, อาร์เรย์, ค่า null)
• รูปแบบสตริง (`format`: อีเมล, uuid, วัน-เวลา, ฯลฯ)
• การจับคู่รูปแบบสำหรับสตริง (`pattern`)
• ช่วงของตัวเลข (`minimum`, `maximum`)
• การตรวจสอบความยาวอาร์เรย์และรายการ (`minItems`, `maxItems`, `items`)
• การตรวจสอบความถูกต้องซ้อนสำหรับอ็อบเจ็กต์และอาร์เรย์
• ข้อจำกัดแบบเอนั่ม (`enum`)

ตัวอย่าง: โครงสร้างผู้ใช้ (ร่าง-07)

{
  "type": "วัตถุ",
  "properties": {
    "id":    { "type": "สตริง", "format": "uuid" },
    "name":  { "type": "สตริง", "minLength": 1 },
    "email": { "type": "สตริง", "format": "อีเมล" },
    "is_active": { "type": "บูลีน" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

สิ่งที่สิ่งนี้บังคับใช้:

• รหัสประจำตัวต้องเป็นสตริง UUID ที่ถูกต้องตามมาตรฐาน
• ชื่อจะต้องเป็นสตริงที่ไม่ว่างเปล่า
• อีเมลต้องตรงกับรูปแบบอีเมลมาตรฐาน
• is_active (ไม่บังคับ) ต้องเป็นค่าบูลีนเท่านั้น
• ไม่อนุญาตให้มีคุณสมบัตินอกเหนือจากที่กำหนดไว้ข้างต้น

ตัวอย่างจริง: การตรวจสอบการตอบกลับ API ของ Stripe

สมมติว่าคุณได้รับการตอบกลับ JSON จาก API ของ Stripe (เช่น PaymentIntent) การตรวจสอบสคีมาจะช่วยให้มั่นใจได้ว่าคุณจะไม่ประมวลผลข้อมูลที่ไม่ครบถ้วนหรือข้อมูลที่มีประเภทผิดพลาด

{
  "type": "วัตถุ",
  "properties": {
    "id": { "type": "สตริง", "pattern": "^pi_" },
    "object": { "type": "สตริง", "const": "payment_intent" },
    "amount": { "type": "จำนวนเต็ม", "minimum": 1 },
    "currency": { "type": "สตริง", "minLength": 3, "maxLength": 3 },
    "status": { "type": "สตริง", "enum": [
      "ต้องการวิธีการชำระเงิน",
      "ต้องการการยืนยัน",
      "กำลังประมวลผล",
      "ชำระเงินสำเร็จ",
      "ยกเลิก"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• รหัสต้องเริ่มต้นด้วย "pi_"
• วัตถุจะต้องเป็น "payment_intent" เสมอ
• จำนวนต้องเป็นจำนวนเต็มและมีค่ามากกว่าหรือเท่ากับ 1
• สกุลเงินต้องเป็นสตริง 3 ตัวอักษร (เช่น "usd", "eur")
• สถานะต้องเป็นหนึ่งในค่าที่กำหนดไว้

ประโยชน์

• ตรวจจับข้อผิดพลาดล่วงหน้า: พบความเปลี่ยนแปลง API ที่ทำให้เกิดปัญหาหรือข้อมูลไม่สมบูรณ์ก่อนที่จะส่งผลกระทบต่อระบบธุรกิจของคุณ
• การทดสอบอัตโนมัติ: ใช้สคีมาในกระบวนการ CI/CD เพื่อยืนยันผลตอบกลับจริงและตัวอย่าง
• ความสม่ำเสมอระหว่างทีม: มาตรฐานข้อตกลงข้อมูลระหว่างส่วนหน้า ส่วนหลัง และ API จากบุคคลที่สาม

การตรวจสอบ JSON ที่ถูกต้อง—ทั้งในด้านไวยากรณ์และโครงสร้าง—ช่วยป้องกันข้อผิดพลาดที่ซับซ้อน ส่งเสริมแนวปฏิบัติที่ดีที่สุด และเพิ่มความปลอดภัยให้แอปพลิเคชันของคุณจากข้อมูลที่ผิดรูปแบบหรือเป็นอันตราย ไม่ว่าจะใช้ในไฟล์กำหนดค่า ข้อมูล API หรือการสื่อสารระหว่างบริการ การตรวจสอบที่มีประสิทธิภาพคือพื้นฐานสำคัญของระบบซอฟต์แวร์สมัยใหม่

ความเป็นส่วนตัวและความปลอดภัย

การตรวจสอบความถูกต้องและโครงสร้างทั้งหมดทำงานบนเบราว์เซอร์ของคุณโดยตรง ไม่มีการอัปโหลดหรือบันทึกข้อมูล ข้อมูล JSON ของคุณจะเป็นความลับอย่างสมบูรณ์

ตัวอย่างโค้ดสำหรับการตรวจสอบ JSON

ดูวิธีการตรวจสอบความถูกต้องของ JSON ในภาษาการเขียนโปรแกรมต่างๆ โดยใช้ไลบรารีมาตรฐานหรือเฟรมเวิร์กที่เป็นที่นิยม ตัวอย่างเหล่านี้แสดงการตรวจสอบความถูกต้องทั้งไวยากรณ์ (syntax validation) และการตรวจสอบตามโครงสร้างข้อมูล (schema validation)

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

const Ajv = require("ajv");
const ajv = new Ajv();
const schema = { type: "object", properties: { age: { type: "integer" } }, required: ["age"] };
const data = { age: 30 };
const validate = ajv.compile(schema);
console.log(validate(data) ? "Valid!" : ajv.errorsText(validate.errors));

import json
try:
    obj = json.loads('{"name":"Alice","age":30}')
    print("Valid JSON:", obj)
except json.JSONDecodeError as e:
    print("Invalid JSON:", e)

import json, jsonschema
schema = {
    "type": "object",
    "properties": { "age": { "type": "integer" } },
    "required": ["age"]
}
data = {"age": 30}
try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print("Schema validation error:", e)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  data := []byte(`{"name":"Alice","age":30}`)
  var obj map[string]interface{}
  if err := json.Unmarshal(data, &obj); err != nil {
    fmt.Println("Invalid JSON:", err)
  } else {
    fmt.Println("Valid JSON:", obj)
  }
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) {
    String json = "{"name":"Alice","age":30}";
    try {
      Object obj = new ObjectMapper().readTree(json);
      System.out.println("Valid JSON: " + obj);
    } catch (Exception e) {
      System.out.println("Invalid JSON: " + e.getMessage());
    }
  }
}

using System;
using System.Text.Json;
class Program {
  static void Main() {
    string json = "{"name":"Alice","age":30}";
    try {
      var doc = JsonDocument.Parse(json);
      Console.WriteLine("Valid JSON!");
    } catch (JsonException e) {
      Console.WriteLine("Invalid JSON: " + e.Message);
    }
  }
}

<?php
$json = '{"name":"Alice","age":30}';
$obj = json_decode($json);
if (json_last_error() === JSON_ERROR_NONE) {
  echo "Valid JSON";
} else {
  echo "Invalid JSON: " . json_last_error_msg();
}

require 'json'
begin
  obj = JSON.parse('{"name":"Alice","age":30}')
  puts "Valid JSON!"
rescue JSON::ParserError => e
  puts "Invalid JSON: #{e.message}"
end

echo '{"name":"Alice","age":30}' | jq empty && echo "Valid" || echo "Invalid"

fn main() {
  let data = r#"{"name":"Alice","age":30}"#;
  match serde_json::from_str::<serde_json::Value>(data) {
    Ok(_) => println!("Valid JSON!"),
    Err(e) => println!("Invalid JSON: {}", e),
  }
}

import org.json.JSONObject
fun main() {
  try {
    val obj = JSONObject("{\"name\":\"Alice\",\"age\":30}")
    println("Valid JSON: $obj")
  } catch (e: Exception) {
    println("Invalid JSON: ${e.message}")
  }
}

import Foundation
let json = "{\"name\":\"Alice\",\"age\":30}"
if let data = json.data(using: .utf8) {
  do {
    let _ = try JSONSerialization.jsonObject(with: data)
    print("Valid JSON!")
  } catch {
    print("Invalid JSON: \(error)")
  }
}

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

SELECT '{"name":"Alice","age":30}'::jsonb; -- Will error if not valid JSON

SELECT JSON_VALID('{"name":"Alice","age":30}');

$json = '{"name":"Alice","age":30}'
try {
  $obj = $json | ConvertFrom-Json
  Write-Output "Valid JSON!"
} catch {
  Write-Output "Invalid JSON: $($_.Exception.Message)"
}

use JSON;
my $str = '{"name":"Alice","age":30}';
eval { decode_json($str) };
print $@ ? "Invalid JSON: $@" : "Valid JSON!";

import 'dart:convert';
void main() {
  const jsonString = '{"name":"Alice","age":30}';
  try {
    final obj = jsonDecode(jsonString);
    print('Valid JSON: $obj');
  } catch (e) {
    print('Invalid JSON: $e');
  }
}

json = ~s({"name":"Alice","age":30})
case Jason.decode(json) do
  {:ok, _} -> IO.puts("Valid JSON!")
  {:error, err} -> IO.puts("Invalid JSON: #{err}")
end

import play.api.libs.json._
object Main extends App {
  val str = """{"name":"Alice","age":30}"""
  try {
    val json = Json.parse(str)
    println("Valid JSON!")
  } catch {
    case e: Exception => println("Invalid JSON: " + e.getMessage)
  }
}

เกี่ยวกับเครื่องมือนี้