JSON tikrintuvas

Kas yra JSON tikrinimas?

JSON (JavaScript objektų žymėjimas) yra plačiai naudojamas, lengvas duomenų mainų formatas, sukurtas būti lengvai suprantamu žmonėms ir paprastai apdorojamu kompiuteriams. Jo pagrindinė paskirtis – struktūrizuotų duomenų, tokių kaip objektai, masyvai, tekstinės eilutės, skaičiai, loginės reikšmės ir null reikšmės, pateikimas nepriklausomai nuo programavimo kalbos.

JSON validacija yra procesas, kai programiškai tikrinama, ar JSON dokumentas yra tiek sintaksiškai, tiek struktūriškai teisingas. Tai apima dviejų pagrindinių aspektų patikrinimą:

• Sintaksinė patikra: Užtikrinant, kad žali tekstai atitiktų oficialią gramatiką, apibrėžtą pagal ECMA-404 JSON specifikaciją. Analizatoriai daugelyje šiuolaikinių programavimo kalbų (pvz., JSON.parse() JavaScript, json.loads() Python, JSONDecoder Java) tikisi galiojančios sintaksės ir sukels klaidas, jei įvestis bus netinkamai suformuota.
• Struktūrinis (schemos) tikrinimas: Be sintaksės, schemos tikrinimas patikrina, ar JSON duomenys atitinka numatytą struktūrą, įskaitant duomenų tipus, privalomus laukus, reikšmių apribojimus ir įdėtus objektus/masyvus. Schema validacija dažniausiai atliekama naudojant JSON Schema – standartą, kuris apibrėžia taisykles, kas laikoma galiojančiais duomenimis.

Kodėl verta tikrinti JSON?

JSON validacija yra būtina kiekvienu atveju, kai duomenys serializuojami perdavimui, saugojimui ar paslaugų tarpusavio komunikacijai. Pagrindinės priežastys yra šios:

• Klaidų Prevencija: Anksti aptikite ir praneškite apie sintaksės klaidas (pvz., trūkstamus kablelius, neatitinkančias skliaustelius, netinkamus simbolius) – prieš pradėdami apdoroti duomenis.
• Duomenų vientisumas ir saugumas: Atmesti netinkamai suformuotus arba kenksmingus JSON paketus, taip padedant išvengti serverio gedimų, įpurškimo atakų ar duomenų korupcijos.
• Tipų saugumas: Užtikrinkite griežtą tipų laikymąsi – pavyzdžiui, kad laukas, kuris turėtų būti loginė reikšmė (boolean), nebūtų siunčiamas kaip tekstas, arba kad UUID, el. paštas ar skaičiai atitiktų tinkamą formatą.
• Tarpkalbinis suderinamumas: Užtikrinkite, kad JSON, sukurtas vienoje aplinkoje (pvz., Node.js), būtų saugiai naudojamas kitoje (pvz., Python, Go, Java), išvengiant seralizavimo/deseralizavimo klaidų.
• Prižiūrimumas ir patikimumas: Patikrintos duomenų struktūros pagerina sekamumą ir sumažina sunkiai ištaisomų klaidų konfigūracijos failuose, žurnaluose ar API užklausose/atsakymuose riziką.
• Privatumas ir saugumas: validacija gali būti atliekama visiškai kliento pusėje (naršyklėje), užkertant kelią žaliems ar jautriems duomenims palikti vartotojo įrenginį validacijai atlikti.

Dažnos JSON validacijos klaidos (su išsamiais pavyzdžiais)

Raktiniai žodžiai be kabučių

Visi raktai JSON objektuose turi būti dvigubai kabutėse įrašyti tekstiniai simboliai.

{ name: "Alisa" }

{ "name": "Alisa" }

Daugelis JSON tipo formatų (pvz., JavaScript objektų literaliai) leidžia naudoti raktus be kabučių, tačiau standartinis JSON to neleidžia.

Viengubos kabutės

JSON eilutės turi naudoti tik dvigubas kabutes; viengubos kabutės yra neleistinos.

{ 'name': 'Bobas' }

{ "name": "Bobas" }

Naudojant viengubas kabutes bus generuojamos analizatoriaus klaidos visose atitinkančiose JSON bibliotekose.

Galūninės kableliai

Nėra kablelio po paskutinio elemento objekte arba masyve.

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

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

Galimos kablelių pabaigos žymos JavaScript kalboje, tačiau griežtuose JSON analizatoriuose jos neveikia.

Netinkamas simbolių pabėgimas

Citatos ir specialieji simboliai eilutėse turi būti „išvengti“ naudojant atgalinį brūkšnį.

{ "quote": "Tom sakė „labas"" }

{ "quote": "Tomas pasakė \"labas\"" }

Kitos ištrūkimo sekos apima \\ skirtą atgalinei brūkšneliui, \n naujoms eilutėms ir \t tabuliacijoms.

Neteisingi duomenų tipai

Skaičiams, loginėms reikšmėms arba null vertėms naudoti nereikėtų tekstinių eilutų.

{ "enabled": "įjungta", "count": "10" }

{ "įjungta": true, "skaičius": 10 }

JSON atskiria logines reikšmes, skaičius ir eilutes – užtikrinkite, kad būtų naudojamas teisingas tipas.

Neprimitiniai raktai

JSON objekto raktai visada turi būti eilutės; negalite naudoti skaičių, loginės reikšmės ar kitų tipų kaip raktų.

{ 123: "abc" }

{ "123": "abc" }

Dublikatai raktai

Nors pagal JSON specifikaciją tai leidžiama, pasikartojantys raktai dažnai sukelia klaidų.

{ "name": "Alicė", "name": "Bobas" }

Dauguma analizatorių išsaugo tik paskutinę reikšmę („Bob“), tyliai ignoruodami ankstesnes.

Komentarų naudojimas

Standartinis JSON formatas neleidžia komentarų, nors kai kurie redaktoriai juos palaiko.

{
  // Naudotojo informacija
  "name": "Alicė"
}

{
  "name": "Alicė"
}

Schemos tikrinimas: struktūros ir duomenų tipų užtikrinimas

JSON Schema yra galingas standartas, skirtas apibrėžti ir patikrinti JSON dokumentų struktūrą. Jis leidžia jums nurodyti:

• Privalomi laukai (`required`)
• Duomenų tipai (`type`: eilutė, skaičius, loginė reikšmė, objektas, masyvas, null reikšmė)
• Eilutės formatai (`format`: el. paštas, uuid, data ir laikas ir kt.)
• Eilučių atitikimas pagal šabloną („pattern“)
• Skaičių intervalai („minimalus“, „maksimalus“)
• Masyvo ilgio ir elementų validacija (`minItems`, `maxItems`, `items`)
• Įdėtinė objektų ir masyvų tikrinimo validacija
• Išvardinimo apribojimai (`enum`)

Pavyzdys: Vartotojo schema (Juodraštis-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
}

Ką tai užtikrina:

• id turi būti galiojanti UUID eilutė.
• vardas turi būti ne tuščias tekstas.
• el. paštas turi atitikti standartinį el. pašto formatą.
• is_active (pasirenkamas) turi būti loginė (boolean) reikšmė.
• Leidžiamos tik aukščiau nurodytos savybės.

Tikras Pavyzdys: Stripe API Atsakymų Tikrinimas

Tarkime, kad gaunate JSON atsakymus iš Stripe API (pvz., PaymentIntent). Schemos patikra užtikrina, kad niekada neapdorosite neišsamios arba neteisingo tipo duomenų.

{
  "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": [
      "reikalauja_mokėjimo_metodo",
      "reikalauja_patvirtinimo",
      "vykdoma",
      "pavyko",
      "atšaukta"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• ID turi prasidėti nuo „pi_“
• objektas visada turi būti „payment_intent“
• suma turi būti sveikasis skaičius, didesnis arba lygus 1
• valiuta turi būti trijų raidžių eilutė (pvz., „usd“, „eur“)
• būsena turi būti viena iš nurodytų reikšmių

Privalumai

• Ankstyvas klaidų aptikimas: nustatykite kritinius API pakeitimus ar neišsamias duomenis dar prieš jiems pasiekiant jūsų verslo logiką.
• Automatizuotas testavimas: Naudokite schemas CI/CD procesuose tikrų ir imituotų atsakymų patikrinimui.
• Tarpkomandinis nuoseklumas: standartizuokite duomenų sutartis tarp frontend, backend ir trečiųjų šalių API.

Tinkamas JSON validavimas – apimantis tiek sintaksę, tiek schemą – padeda išvengti subtilių klaidų, užtikrina geriausias praktikas ir apsaugo jūsų programas nuo netvarkingų ar kenksmingų įrašų. Nesvarbu, ar tai būtų konfigūracijos failai, API duomenų paketas ar tarpservisinė žinučių perdavimo sistema, patikimas validavimas yra pagrindas šiuolaikinėms programinės įrangos sistemoms.

Privatumas ir saugumas

Visi validacijos ir schemos patikrinimai vykdomi tiesiogiai jūsų naršyklėje. Jokie duomenys nėra įkeliami ar registruojami. Jūsų JSON išlieka visiškai privačiai.

Kodo pavyzdžiai JSON galiojimui tikrinti

Sužinokite, kaip patikrinti JSON galiojimą įvairiomis programavimo kalbomis, naudodamiesi įmontuotomis bibliotekomis arba populiariais karkasais. Šie pavyzdžiai demonstruoja tiek sintaksės, tiek schemos validaciją.

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

Apie šį įrankį