JSON Érvényesítő

Mi az a JSON érvényesítés?

A JSON (JavaScript Object Notation) egy széles körben használt, könnyű adatcsere-formátum, amelyet úgy terveztek, hogy egyszerre legyen ember által olvasható és gépek számára könnyen feldolgozható és létrehozható. Fő célja a strukturált adatok – objektumok, tömbök, karakterláncok, számok, logikai értékek és nullák – nyelvfüggetlen ábrázolása.

A JSON érvényesítés folyamata annak programozott ellenőrzése, hogy egy JSON dokumentum szintaktikailag és szerkezetileg is helyes-e. Ez magában foglalja két fő szempont ellenőrzését:

• Szinaktikai érvényesítés: Biztosítva, hogy a nyers szöveg megfeleljen az ECMA-404 JSON specifikáció szerinti formális nyelvtannak. A legtöbb modern programozási nyelv elemzői (például a JSON.parse() JavaScriptben, json.loads() Pythonban, JSONDecoder Javában) érvényes szintaxist várnak el, és hibát jeleznek, ha a bemenet hibás formátumú.
• Szerkezeti (Séma) Érvényesítés: A szintaxison túl a séma-ellenőrzés biztosítja, hogy a JSON adatok megfeleljenek a várható struktúrának, beleértve az adattípusokat, a kötelező tulajdonságokat, az értékek korlátozásait, valamint a beágyazott objektumokat és tömböket. A séma-ellenőrzést általában JSON Sémával végzik, amely meghatározza az érvényes adatokra vonatkozó szabályokat.

Miért ellenőrizzük a JSON-t?

A JSON érvényesítés elengedhetetlen, amikor adatokat sorosítanak átvitelhez, tároláshoz vagy szolgáltatások közötti kommunikációhoz. A legfontosabb okok a következők:

• Hiba megelőzése: Azonosítsa és jelezze a szintaktikai hibákat (pl. hiányzó vesszők, nem egyező zárójelek, tiltott karakterek) időben, még az adatok feldolgozása előtt.
• Adatintegritás és biztonság: Elutasítja a hibás vagy rosszindulatú JSON adatcsomagokat, megakadályozva a backend összeomlását, injekciós támadásokat és az adatok sérülését.
• Típusbiztonság: Szigorú típusellenőrzés érvényesítése—például annak biztosítása, hogy egy logikai értékként elvárt mező ne kerüljön sztringként elküldésre, illetve hogy az UUID-k, e-mailek és számok a megfelelő formátumnak feleljenek meg.
• Kereszt-nyelvi kompatibilitás: Garantálja, hogy egy adott környezetben (például Node.js) létrehozott JSON biztonságosan felhasználható legyen más környezetben (például Python, Go, Java), elkerülve a sorosítási és deszerializációs hibákat.
• Karbantarthatóság és Robosztusság: Az érvényesített adatstruktúrák javítják a nyomonkövethetőséget, és csökkentik a nehezen hibakereshető hibák kockázatát konfigurációs fájlokban, naplókban vagy API kérések/válaszok során.
• Adatvédelem és biztonság: Az érvényesítés teljes egészében ügyféloldalon (böngészőben) történhet, megakadályozva, hogy nyers vagy érzékeny adatok elhagyják a felhasználó eszközét az érvényesítés céljából.

Gyakori JSON érvényesítési hibák (részletes példákkal)

Idézet nélküli kulcsok

A JSON objektumok összes kulcsa dupla idézőjelek közé tett sztring kell, hogy legyen.

{ name: "Alice" }

{ "name": "Alice" }

Számos JSON-szerű formátum (például JavaScript objektum literálok) engedélyezi az idézőjelek nélküli kulcsokat, de a szabványos JSON ezt nem támogatja.

Egyszeres idézőjelek

A JSON karakterláncoknak kizárólag dupla idézőjeleket kell használniuk; az egyes idézőjelek nem megengedettek.

{ 'név': 'Bob' }

{ "name": "Bob" }

Egyszeres idézőjelek használata elemzőhibákat okoz minden szabványos JSON könyvtárban.

Vessző a sor végén

Ne legyen vessző az objektum vagy tömb utolsó elemét követően.

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

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

A lezáró vesszők működhetnek JavaScript-ben, de szigorú JSON elemzőkben nem.

Karakterek helytelen elválasztása

A idézőjeleket és speciális karaktereket a sztringeken belül visszaperrel kell escape-elni.

{ "quote": "Tom azt mondta: \"szia\"" }

{ "quote": "Tom azt mondta: \"szia\"" }

Egyéb speciális karakterek közé tartozik a \\ a visszaperjelhez, a \n az új sorokhoz, és a \t a tabulátorokhoz.

Helytelen adattípusok

A számok, logikai értékek vagy null értékek esetén ne használjunk karakterláncokat.

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

{ "engedélyezve": true, "darab": 10 }

A JSON megkülönbözteti a logikai értékeket, számokat és szöveges adatokat – ügyelj rá, hogy a megfelelő típust használd.

Nem primitív kulcsok

A JSON objektum kulcsai mindig karakterláncok kell, hogy legyenek; nem használhatók számok, logikai értékek vagy más típusok kulcsként.

{ 123: "abc" }

{ "123": "abc" }

Ismétlődő kulcsok

Bár a JSON szabvány engedélyezi, a duplikált kulcsok gyakori hibaforrások.

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

A legtöbb elemző csak az utolsó értéket ("Bob") tartja meg, a korábbiakat pedig észrevétlenül elveti.

Kommentek használata

A szabványos JSON nem engedélyezi a megjegyzéseket, bár egyes szerkesztők támogatják azokat.

{
  // Felhasználói információ
  "name": "Alice"
}

{
  "name": "Alice"
}

Sémaellenőrzés: Struktúra és adattípusok érvényesítése

A JSON Schema egy hatékony szabvány a JSON dokumentumok várt szerkezetének meghatározására és érvényesítésére. Lehetővé teszi, hogy megadja:

• Kötelező mezők (`required`)
• Adattípusok (`type`: szöveg, szám, logikai érték, objektum, tömb, null)
• Karakterlánc formátumok (`format`: email, uuid, dátum-idő, stb.)
• Mintaillesztés karakterláncokhoz (`pattern`)
• Számértéktartományok (`minimum`, `maximum`)
• Tömb hosszának és elemeinek érvényesítése (`minItems`, `maxItems`, `items`)
• Beágyazott érvényesítés objektumokhoz és tömbökhöz
• Enum korlátozások (`enum`)

Példa: Felhasználói séma (Draft-07)

{
  "type": "objektum",
  "properties": {
    "id":    { "type": "sztring", "format": "uuid" },
    "name":  { "type": "sztring", "minLength": 1 },
    "email": { "type": "sztring", "format": "email" },
    "is_active": { "type": "logikai" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Ez által betartandó:

• Az azonosítónak érvényes UUID formátumúnak kell lennie.
• a név nem lehet üres szöveg.
• Az e-mailnek meg kell felelnie a szabványos e-mail formátumnak.
• is_active (opcionális) értéke logikai típusú kell, hogy legyen.
• Csak a fent meghatározott tulajdonságok engedélyezettek.

Valós példa: Stripe API válaszok hitelesítése

Tegyük fel, hogy JSON válaszokat kap a Stripe API-tól (például PaymentIntent). A sémaellenőrzés biztosítja, hogy soha ne dolgozzon fel hiányos vagy helytelen típusú adatokat.

{
  "type": "objektum",
  "properties": {
    "id":      { "type": "sztring", "pattern": "^pi_" },
    "object":  { "type": "sztring", "const": "payment_intent" },
    "amount":  { "type": "egész", "minimum": 1 },
    "currency":{ "type": "sztring", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "sztring", "enum": [
      "fizetési_mód_szükséges",
      "megerősítés_szükséges",
      "feldolgozás_alatt",
      "sikeres",
      "mégse"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• azonosítónak "pi_"-vel kell kezdődnie
• az objektumnak mindig "payment_intent" típusúnak kell lennie
• az összegnek 1-nél nagyobb vagy azzal egyenlő egész számnak kell lennie
• a pénznemnek hárombetűs karakterláncnak kell lennie (pl. "usd", "eur")
• az állapotnak a megadott értékek egyikének kell lennie

Előnyök

• Korai hibafelismerés: Észlelje az API-töréseket vagy hiányos adatokat még az előtt, hogy elérnék az üzleti logikát.
• Automatizált tesztelés: Használjon sémákat CI/CD folyamatokban valós és tesztválaszok érvényesítésére.
• Csapatok közötti következetesség: Standardizálja az adatmegállapodásokat a frontend, a backend és a harmadik féltől származó API-k között.

Megfelelő JSON érvényesítés — amely mind a szintaxist, mind a sémát lefedi — megelőzi a rejtett hibákat, érvényesíti a bevált gyakorlatokat, és védi alkalmazásait a helytelen vagy rosszindulatú bemenetek ellen. Legyen szó konfigurációs fájlokról, API üzenetekről vagy szolgáltatások közötti kommunikációról, a megbízható érvényesítés alapvető eleme a modern szoftverrendszereknek.

Adatvédelem és Biztonság

Minden érvényesítés és sémaellenőrzés helyben, a böngészőben történik. Nincs adatfeltöltés vagy naplózás. A JSON fájlod teljes mértékben privát marad.

Kódpéldák JSON érvényesítéséhez

Nézze meg, hogyan lehet JSON-t érvényesíteni különböző programozási nyelveken beépített könyvtárak vagy népszerű keretrendszerek segítségével. Ezek a példák bemutatják mind a szintaxis ellenőrzést, mind a séma validációt.

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

Erről az eszközről