Validator JSON

Apa Itu Validasi JSON?

JSON (JavaScript Object Notation) adalah format pertukaran data ringan yang banyak digunakan, dirancang agar mudah dibaca oleh manusia sekaligus mudah diurai dan dihasilkan oleh mesin. Tujuan utamanya adalah untuk merepresentasikan data terstruktur—objek, array, string, angka, boolean, dan null—dengan cara yang tidak tergantung pada bahasa pemrograman.

Validasi JSON adalah proses memverifikasi secara programatik bahwa sebuah dokumen JSON benar secara sintaksis dan struktural. Ini melibatkan pemeriksaan dua aspek utama:

• Validasi Sintaksis: Memastikan bahwa teks mentah mengikuti tata bahasa formal sebagaimana didefinisikan oleh spesifikasi JSON ECMA-404. Parser pada sebagian besar bahasa pemrograman modern (misalnya, JSON.parse() di JavaScript, json.loads() di Python, JSONDecoder di Java) mengharapkan sintaks yang valid dan akan menghasilkan kesalahan jika inputnya tidak sesuai.
• Validasi Struktural (Skema): Selain sintaks, validasi skema memeriksa bahwa data JSON sesuai dengan struktur yang diharapkan, termasuk tipe data, properti yang wajib ada, batasan nilai, serta objek/array yang bersarang. Validasi skema biasanya dilakukan menggunakan JSON Schema, yang menetapkan aturan untuk data yang dianggap valid.

Mengapa Memvalidasi JSON?

Validasi JSON sangat penting di mana pun data diserialisasi untuk transmisi, penyimpanan, atau komunikasi antar layanan. Alasan utamanya meliputi:

• Pencegahan Kesalahan: Deteksi dan laporkan kesalahan sintaks (misalnya, koma yang hilang, tanda kurung tidak cocok, karakter ilegal) sejak awal—sebelum memproses data.
• Integritas & Keamanan Data: Tolak payload JSON yang rusak atau berbahaya, membantu mencegah kerusakan backend, serangan injeksi, atau korupsi data.
• Keamanan Tipe: Terapkan pengetikan ketat—memastikan, misalnya, bahwa sebuah bidang yang diharapkan berupa boolean tidak dikirim sebagai string, atau bahwa UUID, email, atau angka mengikuti format yang benar.
• Kompatibilitas Lintas Bahasa: Pastikan JSON yang dibuat di satu lingkungan (misalnya, Node.js) dapat digunakan dengan aman di lingkungan lain (misalnya, Python, Go, Java), menghindari bug pada proses serialisasi/deserialisasi.
• Pemeliharaan & Ketangguhan: Struktur data yang tervalidasi meningkatkan keterlacakan dan mengurangi risiko kesalahan yang sulit di-debug dalam file konfigurasi, log, atau permintaan/respons API.
• Privasi & Keamanan: Validasi dapat dilakukan sepenuhnya di sisi klien (di dalam browser), mencegah data mentah atau sensitif keluar dari perangkat pengguna untuk proses validasi.

Kesalahan Validasi JSON Umum (dengan Contoh Detail)

Kunci Tanpa Tanda Kutip

Semua kunci dalam objek JSON harus berupa string yang diapit tanda kutip ganda.

{ nama: "Alice" }

{ "name": "Alice" }

Banyak format mirip JSON (misalnya, literal objek JavaScript) mengizinkan kunci tanpa tanda kutip, namun JSON standar tidak memperbolehkannya.

Tanda Petik Tunggal

String JSON harus menggunakan tanda kutip ganda saja; tanda kutip tunggal tidak diperbolehkan.

{ 'nama': 'Bob' }

{ "name": "Bob" }

Menggunakan tanda kutip tunggal akan menyebabkan kesalahan parser di semua pustaka JSON yang sesuai standar.

Koma Akhir

Jangan gunakan koma di akhir setelah item terakhir dalam sebuah objek atau array.

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

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

Koma di akhir baris mungkin berfungsi di JavaScript, tetapi tidak di parser JSON yang ketat.

Penggunaan Karakter Escape yang Tidak Tepat

Tanda kutip dan karakter khusus di dalam string harus di-escape menggunakan garis miring terbalik (backslash).

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

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

Urutan pelolosan lain termasuk \\ untuk garis miring terbalik, \n untuk baris baru, dan \t untuk tabulasi.

Jenis Data Salah

String tidak boleh digunakan untuk angka, boolean, atau null.

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

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

JSON membedakan antara boolean, angka, dan string—pastikan jenis yang tepat digunakan.

Kunci Non-Primitif

Kunci objek JSON harus selalu berupa string; Anda tidak dapat menggunakan angka, boolean, atau tipe lain sebagai kunci.

{ 123: "abc" }

{ "123": "abc" }

Kunci Duplikat

Meskipun diperbolehkan oleh spesifikasi JSON, duplikasi kunci sering menjadi sumber kesalahan.

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

Sebagian besar parser hanya akan menyimpan nilai terakhir ("Bob"), secara diam-diam mengabaikan nilai-nilai sebelumnya.

Penggunaan Komentar

JSON standar tidak mengizinkan komentar, meskipun beberapa editor mendukungnya.

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

{
  "name": "Alice"
}

Validasi Skema: Menegakkan Struktur dan Tipe Data

JSON Schema adalah standar yang kuat untuk mendefinisikan dan memvalidasi struktur yang diharapkan dari dokumen JSON. Ini memungkinkan Anda untuk menetapkan:

• Kolom wajib diisi (`required`)
• Tipe data (`type`: string, number, boolean, object, array, null)
• Format string (`format`: email, uuid, tanggal-waktu, dll.)
• Pencocokan pola untuk string (`pattern`)
• Rentang angka (`minimum`, `maksimum`)
• Panjang array dan validasi item (`minItems`, `maxItems`, `items`)
• Validasi bersarang untuk objek dan array
• Keterbatasan enum (`enum`)

Contoh: Skema Pengguna (Draft-07)

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

Apa yang ditegakkan oleh ini:

• id harus berupa string UUID yang valid.
• nama harus berupa string yang tidak kosong.
• email harus sesuai dengan format email standar.
• is_active (opsional) harus berupa nilai boolean.
• Tidak ada properti lain selain yang telah didefinisikan di atas yang diperbolehkan.

Contoh Dunia Nyata: Memvalidasi Respon API Stripe

Misalkan Anda menerima respons JSON dari API Stripe (misalnya, PaymentIntent). Validasi skema dapat memastikan Anda tidak pernah memproses data yang tidak lengkap atau memiliki tipe yang salah.

{
  "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": [
      "memerlukan_metode_pembayaran",
      "memerlukan_konfirmasi",
      "sedang_diproses",
      "berhasil",
      "dibatalkan"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• ID harus diawali dengan "pi_"
• objek harus selalu "payment_intent"
• jumlah harus berupa bilangan bulat yang lebih besar dari atau sama dengan 1
• mata uang harus berupa string tiga huruf (misalnya, "usd", "eur")
• status harus salah satu dari nilai yang ditentukan

Manfaat

• Deteksi Kesalahan Dini: Tangkap perubahan API yang merusak atau data yang tidak lengkap sebelum mencapai logika bisnis Anda.
• Pengujian Otomatis: Gunakan skema dalam pipeline CI/CD untuk memvalidasi respons nyata dan tiruan.
• Konsistensi Lintas Tim: Standarisasi kontrak data antara frontend, backend, dan API pihak ketiga.

Validasi JSON yang tepat—meliputi sintaks dan skema—mencegah bug tersembunyi, menegakkan praktik terbaik, dan mengamankan aplikasi Anda dari input yang salah bentuk atau berbahaya. Baik digunakan dalam file konfigurasi, payload API, atau komunikasi antar layanan, validasi yang kuat adalah pondasi penting untuk sistem perangkat lunak modern.

Privasi & Keamanan

Semua validasi dan pemeriksaan skema dijalankan secara lokal di browser Anda. Tidak ada data yang diunggah atau dicatat. JSON Anda tetap sepenuhnya pribadi.

Contoh Kode untuk Validasi JSON

Lihat cara memvalidasi JSON dalam berbagai bahasa pemrograman menggunakan pustaka bawaan atau kerangka kerja populer. Contoh-contoh ini menunjukkan 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