Tagasuri ng JSON

Ano ang Pag-validate ng JSON?

Ang JSON (JavaScript Object Notation) ay isang malawakang ginagamit, magaan na format para sa pagpapalitan ng datos, na dinisenyo upang maging madaling basahin ng tao at madaling iproseso at likhain ng mga makina. Pangunahing layunin nito ang magpakita ng nakaayos na datos—mga bagay, arrays, mga string, numero, boolean, at null—sa isang paraan na hindi nakadepende sa wika.

Ang pag-validate ng JSON ay ang proseso ng programatikong pag-verify na ang isang JSON na dokumento ay tama sa sintaks at estruktura. Kasama dito ang pagsusuri ng dalawang pangunahing aspeto:

• Sintaktikong Pagpapatunay: Tinitiyak na ang hilaw na teksto ay sumusunod sa pormal na balarila na tinukoy ng ECMA-404 na spesipikasyon ng JSON. Ang mga parser sa karamihan ng moderno nang mga wika sa pagprograma (hal., JSON.parse() sa JavaScript, json.loads() sa Python, JSONDecoder sa Java) ay inaasahang tatanggap ng wastong sintaks at magbibigay ng error kung ang input ay hindi tama ang formato.
• Pagsusuri ng Estruktura (Schema): Higit pa sa sintaks, sinusuri ng schema validation na ang JSON na datos ay tumutugma sa inaasahang estruktura, kabilang ang mga uri ng datos, mga kailangang katangian, mga limitasyon ng halaga, at mga nested na bagay/array. Karaniwang ginagawa ang schema validation gamit ang JSON Schema, na nagtatakda ng mga patakaran para sa kung ano ang itinuturing na wastong datos.

Bakit Mag-validate ng JSON?

Mahalaga ang pag-validate ng JSON sa kahit saan mang bahagi kung saan ang data ay isinasalaysay para sa pagpapadala, imbakan, o komunikasyon sa pagitan ng mga serbisyo. Pangunahing mga dahilan ang mga sumusunod:

• Pag-iwas sa Mali: Tuklasin at i-report agad ang mga syntax error (halimbawa, nawawalang kuwit, hindi magkatugmang panaklong, ipinagbabawal na mga karakter)—bago pa man subukang iproseso ang datos.
• Integridad at Seguridad ng Datos: Tanggihan ang mga maling ayos o mapanirang JSON payloads upang maiwasan ang pag-crash ng backend, mga injection attack, o pagkasira ng datos.
• Kaligtasan sa Uri: Ipatupad ang mahigpit na pagti-type—tinitiyak, halimbawa, na ang isang field na inaasahang boolean ay hindi ipinapadala bilang string, o na ang mga UUID, email, o numero ay sumusunod sa tamang format.
• Pagkakatugma sa Iba't Ibang Wika: Tiyakin na ang JSON na ginawa sa isang kapaligiran (hal., Node.js) ay ligtas na magagamit sa iba pa (hal., Python, Go, Java), na iniiwasan ang mga bug sa serialization/deserialization.
• Madaling Panatilihin at Katatagan: Ang mga na-validate na istruktura ng datos ay nagpapahusay sa pagsubaybay at nagpapababa ng panganib ng mga mahirap ayusing error sa mga configuration file, logs, o API request/response.
• Privacy at Seguridad: Maaaring isagawa ang beripikasyon nang lubusan sa kliyente (sa browser), na pumipigil sa pagkawala ng orihinal o sensitibong datos mula sa aparato ng gumagamit para sa beripikasyon.

Karaniwang Mga Error sa Pag-validate ng JSON (na may Detalyadong Mga Halimbawa)

Mga Key na Walang Panipi

Lahat ng key sa mga JSON object ay dapat naka-double quote na mga string.

{ pangalan: "Alice" }

{ "name": "Alice" }

Maraming mga format na katulad ng JSON (halimbawa, mga literal ng object sa JavaScript) ang nagpapahintulot ng mga susi na walang panipi, ngunit ang standard na JSON ay hindi.

Pangunahing Panipi

Ang mga string sa JSON ay dapat gumamit lamang ng dobleng panipi; hindi pinapayagan ang mga solong panipi.

{ 'pangalan': 'Bob' }

{ "name": "Bob" }

Ang paggamit ng single quotes ay magdudulot ng mga error sa parser sa lahat ng mga librarya ng JSON na sumusunod sa pamantayan.

Mga Huling Kuwit

Walang kuwit sa hulihan matapos ang huling item sa isang object o array.

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

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

Maaaring gumana ang trailing commas sa JavaScript, ngunit hindi ito tinatanggap ng mga mahigpit na JSON parser.

Maling Pag-escape ng mga Karakter

Ang mga panipi at espesyal na karakter sa loob ng mga string ay kailangang i-escape gamit ang backslash.

{ "quote": "Sabi ni Tom, 'kamusta'" }

{ "quote": "Sabi ni Tom \"kumusta\"" }

Kabilang sa iba pang mga escape sequence ang \\ para sa backslash, \n para sa mga bagong linya, at \t para sa mga tab.

Maling Uri ng Datos

Hindi dapat gamitin ang mga string para sa mga numero, boolean, o null.

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

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

Ipinag-iiba ng JSON ang mga boolean, numero, at string—tiyakin na tama ang uri na ginamit.

Hindi-Primitibong Mga Susi

Ang mga susi ng JSON object ay dapat laging nasa anyo ng mga string; hindi ka maaaring gumamit ng mga numero, boolean, o iba pang uri bilang mga susi.

{ 123: "abc" }

{ "123": "abc" }

Dobleng Susi

Bagamat pinapayagan ng JSON spec, ang mga duplicate na susi ay karaniwang sanhi ng mga bug.

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

Karamihan sa mga parser ay itatago lamang ang huling halaga ("Bob"), tahimik na tinatanggal ang mga naunang halaga.

Paggamit ng Mga Komento

Ang karaniwang JSON ay hindi nagpapahintulot ng mga komento, kahit na may ilang mga editor na sumusuporta rito.

{
  // Impormasyon ng gumagamit
  "name": "Alice"
}

{
  "name": "Alice"
}

Pagsusuri ng Schema: Pagpapatupad ng Estruktura at Mga Uri ng Datos

Ang JSON Schema ay isang makapangyarihang pamantayan para sa pagtukoy at pagsuri sa inaasahang estruktura ng mga dokumentong JSON. Pinapahintulutan nito ang pagtutukoy ng:

• Kinakailangang mga patlang (`required`)
• Mga uri ng datos (`type`: string, numero, boolean, object, array, null)
• Mga format ng string (`format`: email, uuid, petsa-oras, at iba pa)
• Paghahanap ng pattern para sa mga string (`pattern`)
• Mga hanay ng numero (`minimum`, `maximum`)
• Pagpapatunay ng haba ng array at mga item (`minItems`, `maxItems`, `items`)
• Pinagsamang pagpapatunay para sa mga object at array
• Mga Paghihigpit ng Enum (`enum`)

Halimbawa: User Schema (Bersyon-Draft-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1, "description": "Pangalan ng gumagamit" },
    "email": { "type": "string", "format": "email", "description": "Email address para sa komunikasyon at pag-login" },
    "is_active": { "type": "boolean", "description": "Nagpapakita kung ang account ay aktibo" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Ano ang pinatitibay nito:

• ang id ay dapat isang wastong UUID na string.
• ang pangalan ay dapat isang hindi walang laman na string.
• ang email ay dapat sumunod sa karaniwang format ng email.
• is_active (opsyonal) ay dapat isang boolean.
• Walang iba pang mga ari-arian maliban sa mga nakasaad sa itaas ang pinapayagan.

Tunay na Halimbawa: Pag-validate ng mga Tugon ng Stripe API

Ipagpalagay na tumatanggap ka ng mga tugon na JSON mula sa Stripe API (hal., PaymentIntent). Ang pagsuri sa schema ay makatitiyak na hindi mo mapoproseso ang hindi kumpleto o maling uri ng datos.

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "payment_intent" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "kailangan_ng_paraan_ng_pagbayad",
      "kailangan_ng_kumpirmasyon",
      "pinoproseso",
      "nagtagumpay",
      "kanselado"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• Ang id ay dapat magsimula sa "pi_"
• ang object ay dapat palaging "payment_intent"
• ang halaga ay dapat isang integer na mas malaki o katumbas ng 1
• ang currency ay dapat isang string na may tatlong letra (halimbawa, "usd", "eur")
• ang estado ay dapat isa sa mga tinukoy na halaga

Mga Benepisyo

• Maagang Pagtuklas ng Error: Agarang makita ang mga pagbabagong sirang API o hindi kumpletong datos bago pa ito makaapekto sa iyong business logic.
• Automatikong Pagsusuri: Gamitin ang mga schema sa CI/CD pipeline upang suriin ang tunay at peke na mga tugon.
• Pagkakapareho sa Iba't Ibang Koponan: I-standardize ang mga kontrata ng datos sa pagitan ng frontend, backend, at mga third-party na API.

Ang wastong pag-validate ng JSON—na sumasaklaw sa parehong syntax at schema—ay pumipigil sa mga maliliit na bug, nagpapatupad ng mga pinakamahuhusay na kasanayan, at pinoprotektahan ang iyong mga aplikasyon laban sa maling anyo o malisyosong input. Gamit man sa mga configuration file, API payload, o messaging sa pagitan ng mga serbisyo, ang matibay na pag-validate ay pundasyon para sa mga makabagong sistema ng software.

Pribadong Impormasyon at Seguridad

Lahat ng pagsusuri at pag-validate ng schema ay isinasagawa nang lokal sa iyong browser. Walang datos na ina-upload o nilalagyan ng log. Nananatiling ganap na pribado ang iyong JSON.

Mga Halimbawa ng Kodigo para sa Pag-validate ng JSON

Tingnan kung paano mag-validate ng JSON gamit ang iba't ibang programming languages gamit ang mga built-in na library o mga kilalang framework. Ipinapakita ng mga halimbawa na ito ang parehong pag-validate ng syntax at ng schema.

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

Tungkol sa tool na ito