Pengesah JSON

Apakah Pengesahan JSON?

JSON (JavaScript Object Notation) adalah format pertukaran data ringan yang banyak digunakan, direka untuk mudah dibaca oleh manusia dan mudah diproses serta dijana oleh mesin. Tujuan utamanya adalah untuk mewakili data berstruktur—objek, tatasusunan, rentetan, nombor, boolean, dan nilai kosong—dengan cara yang tidak bergantung pada bahasa pengaturcaraan.

Pengesahan JSON adalah proses memeriksa secara programatik bahawa dokumen JSON adalah betul dari segi sintaks dan struktur. Ini melibatkan pemeriksaan dua aspek utama:

• Pengesahan Sintaksis: Memastikan teks mentah mematuhi tatabahasa rasmi seperti yang ditetapkan oleh spesifikasi ECMA-404 JSON. Penafsir dalam kebanyakan bahasa pengaturcaraan moden (contohnya, JSON.parse() dalam JavaScript, json.loads() dalam Python, JSONDecoder dalam Java) menjangkakan sintaks yang sah dan akan memaparkan ralat jika input tidak betul.
• Pengesahan Struktur (Skema): Selain sintaks, pengesahan skema memeriksa bahawa data JSON memenuhi struktur yang dijangka, termasuk jenis data, sifat wajib, kekangan nilai, dan objek/array bersarang. Pengesahan skema biasanya dilakukan menggunakan JSON Schema, yang menentukan peraturan untuk data yang dianggap sah.

Mengapa Sahkan JSON?

Pengesahan JSON adalah penting di mana-mana sahaja data diserialkan untuk penghantaran, penyimpanan, atau komunikasi antara perkhidmatan. Sebab-sebab utama termasuk:

• Pencegahan Ralat: Mengesan dan melaporkan ralat sintaks (contohnya, koma yang hilang, kurungan yang tidak padan, aksara haram) dengan awal—sebelum cuba memproses data.
• Integriti & Keselamatan Data: Tolak beban JSON yang salah bentuk atau berniat jahat, membantu mencegah kerosakan sistem backend, serangan suntikan, atau kerosakan data.
• Keselamatan Jenis: Menegakkan pengetikan ketat—memastikan, contohnya, bahawa medan yang dijangka boolean tidak dihantar sebagai rentetan, atau bahawa UUID, emel, atau nombor mengikut format yang betul.
• Keserasian Rentas Bahasa: Pastikan JSON yang dihasilkan dalam satu persekitaran (contohnya, Node.js) boleh digunakan dengan selamat dalam persekitaran lain (contohnya, Python, Go, Java), mengelakkan masalah pengekodan/penyahkod yang boleh menyebabkan pepijat.
• Kebolehpeliharaan & Ketahanan: Struktur data yang disahkan meningkatkan kebolehlacakan dan mengurangkan risiko ralat yang sukar dikesan dalam fail konfigurasi, log, atau permintaan/respon API.
• Privasi & Keselamatan: Pengesahan boleh dilakukan sepenuhnya di sisi klien (dalam pelayar), mengelakkan data mentah atau sensitif daripada dihantar keluar dari peranti pengguna untuk tujuan pengesahan.

Ralat Pengesahan JSON Biasa (dengan Contoh Terperinci)

Kunci Tanpa Petikan

Semua kekunci dalam objek JSON mestilah rentetan yang diapit dengan petikan berganda.

{ name: "Alice" }

{ "name": "Alice" }

Banyak format serupa JSON (contohnya, literal objek JavaScript) membenarkan kunci tanpa tanda petik, tetapi JSON standard tidak membenarkannya.

Petikan Tunggal

Rentetan JSON mesti menggunakan tanda petik berganda sahaja; tanda petik tunggal tidak dibenarkan.

{ 'name': 'Bob' }

{ "name": "Bob" }

Menggunakan tanda petik tunggal akan menyebabkan ralat pengurai dalam semua perpustakaan JSON yang mematuhi piawaian.

Koma Akhir

Tiada koma di akhir selepas item terakhir dalam objek atau tatasusunan.

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

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

Koma belakang mungkin berfungsi dalam JavaScript, tetapi tidak dalam pengurai JSON yang ketat.

Pelarian Watak yang Tidak Betul

Petikan dan aksara khas di dalam rentetan mesti diimbas menggunakan garis miring terbalik.

{ "quote": "Tom berkata \"hai\"" }

{ "quote": "Tom berkata \"hello\"" }

Urutan pelarian lain termasuk \\ untuk garis miring terbalik, \n untuk baris baru, dan \t untuk tab.

Jenis Data Tidak Betul

Rentetan tidak sepatutnya digunakan untuk nombor, booleans, atau null.

{ "enabled": "benar", "count": "10" }

{ "diaktifkan": benar, "kiraan": 10 }

JSON membezakan antara boolean, nombor, dan rentetan—pastikan jenis yang betul digunakan.

Kunci Bukan Primitif

Kunci objek JSON mesti sentiasa berupa rentetan; anda tidak boleh menggunakan nombor, boolean, atau jenis lain sebagai kunci.

{ 123: "abc" }

{ "123": "abc" }

Kunci Pendua

Walaupun dibenarkan oleh spesifikasi JSON, kunci berganda sering menjadi punca biasa masalah perisian.

{ "name": "Alice", "name": "Bob" }

Kebanyakan pengurai hanya akan menyimpan nilai terakhir ("Bob"), tanpa memberi amaran dan membuang nilai-nilai sebelumnya.

Penggunaan Komen

JSON standard tidak membenarkan komen, walaupun sesetengah penyunting menyokongnya.

{
  // Maklumat pengguna
  "name": "Alice"
}

{
  "name": "Alice"
}

Pengesahan Skema: Memastikan Struktur dan Jenis Data

JSON Schema adalah piawaian yang kuat untuk mentakrif dan mengesahkan struktur jangkaan dokumen JSON. Ia membolehkan anda menentukan:

• Medan diperlukan (`required`)
• Jenis data (`type`: string, nombor, boolean, objek, array, null)
• Format rentetan (`format`: emel, uuid, tarikh-masa, dan lain-lain)
• Pencocokan corak untuk rentetan (`pattern`)
• Julat nombor (`minimum`, `maksimum`)
• Panjang array dan pengesahan item (`minItems`, `maxItems`, `items`)
• Pengesahan bertingkat untuk objek dan tatasusunan
• Sekatan enum (`enum`)

Contoh: Skema Pengguna (Draf-07)

{
  "type": "objek",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "emel" },
    "is_active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Apa yang ini tegaskan:

• id mesti merupakan rentetan UUID yang sah.
• nama mesti berupa rentetan yang tidak kosong.
• emel mesti mematuhi format emel standard.
• is_active (pilihan) mesti berupa nilai boolean.
• Tiada harta lain selain yang ditakrifkan di atas dibenarkan.

Contoh Dunia Sebenar: Mengesahkan Respons API Stripe

Andaikan anda menerima respons JSON daripada API Stripe (contohnya, PaymentIntent). Validasi skema dapat memastikan anda tidak pernah memproses data yang tidak lengkap atau jenis yang salah.

{
  "type": "objek",
  "properties": {
    "id":      { "type": "rentetan", "pattern": "^pi_" },
    "object":  { "type": "rentetan", "const": "payment_intent" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{"type": "rentetan", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "rentetan", "enum": [
      "requires_payment_method",  
      "requires_confirmation",  
      "processing",  
      "succeeded",  
      "canceled"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• ID mesti bermula dengan "pi_"
• objek mesti sentiasa "payment_intent"
• jumlah mesti merupakan nombor bulat yang lebih besar atau sama dengan 1
• mata wang mesti dalam bentuk tiga huruf (contoh: "usd", "eur")
• status mesti salah satu daripada nilai yang ditetapkan

Manfaat

• Pengesanan Ralat Awal: Tangkap perubahan API kritikal atau data tidak lengkap sebelum ia sampai ke logik perniagaan anda.
• Ujian Automatik: Gunakan skema dalam saluran CI/CD untuk mengesahkan respons sebenar dan tiruan.
• Konsistensi Antara Pasukan: Seragamkan kontrak data antara frontend, backend, dan API pihak ketiga.

Pengesahan JSON yang betul—meliputi kedua-dua sintaks dan skema—mengelakkan pepijat halus, menguatkuasakan amalan terbaik, dan melindungi aplikasi anda daripada input yang tidak sah atau berniat jahat. Sama ada digunakan dalam fail konfigurasi, muatan API, atau penghantaran mesej antara perkhidmatan, pengesahan yang kukuh adalah asas penting untuk sistem perisian moden.

Privasi & Keselamatan

Semua pengesahan dan pemeriksaan skema dijalankan secara tempatan dalam pelayar anda. Tiada data dimuat naik atau direkodkan. JSON anda kekal sepenuhnya peribadi.

Contoh Kod untuk Pengesahan JSON

Lihat cara memvalidasi JSON dalam pelbagai bahasa pengaturcaraan menggunakan perpustakaan terbina dalam atau rangka kerja popular. Contoh-contoh ini menunjukkan kedua-dua validasi sintaks dan validasi skema.

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)
  }
}

Tentang alat ini