JSON pārbaudītājs

Kas ir JSON validācija?

JSON (JavaScript objekta notācija) ir plaši izmantots un viegls datu apmaiņas formāts, kas izstrādāts tā, lai būtu viegli saprotams cilvēkiem un viegli apstrādājams datorprogrammām. Tā galvenais mērķis ir attēlot strukturētus datus — objektus, masīvus, virknes, skaitļus, patiesības vērtības un nulles — valodai neatkarīgā veidā.

JSON validācija ir process, kurā programmatiski pārbauda, vai JSON dokuments ir gan sintaktiski, gan strukturāli pareizs. Tas ietver divu galveno aspektu pārbaudi:

• Sintaktiskā pārbaude: Nodrošināt, ka izejošais teksts atbilst formālajai gramatikai, kā to nosaka ECMA-404 JSON specifikācija. Lielākā daļa mūsdienīgu programmēšanas valodu analizatori (piemēram, JSON.parse() JavaScript, json.loads() Python, JSONDecoder Java) sagaida derīgu sintaksi un izmet kļūdas, ja ievades dati ir nekorekti.
• Strukturālās (shēmas) pārbaudes: Papildus sintaksei shēmas validācija pārbauda, vai JSON dati atbilst gaidītajai struktūrai, tostarp datu tipiem, obligātajām īpašībām, vērtību ierobežojumiem un iekšējiem objektiem/masīviem. Shēmas validācija parasti tiek veikta, izmantojot JSON shēmu, kas nosaka noteikumus tam, kas tiek uzskatīts par derīgiem datiem.

Kāpēc pārbaudīt JSON?

JSON validācija ir būtiska ikreiz, kad dati tiek serializēti pārraidei, uzglabāšanai vai starp-pakalpojumu saziņai. Galvenie iemesli ir šādi:

• Kļūdu novēršana: Agrīni atklājiet un ziņojiet par sintakses kļūdām (piemēram, trūkstošām komatiem, neatbilstošāmiekavām, aizliegtām rakstzīmēm) — pirms datu apstrādes uzsākšanas.
• Datu integritāte un drošība: Atteikt nederīgus vai ļaunprātīgus JSON datus, palīdzot novērst aizmugures sistēmas avārijas, injekciju uzbrukumus un datu bojājumus.
• Tipsistēma: Nodrošiniet stingru tipu pārbaudi — piemēram, lai lauks, kurš sagaidāms kā Būla tipa vērtība, netiktu nosūtīts kā teksts, vai lai UUID, e-pasti un skaitļi atbilstu pareizam formātam.
• Valodu savietojamība: nodrošiniet, ka JSON, kas izveidots vienā vidē (piemēram, Node.js), ir droši lietojams citā vidē (piemēram, Python, Go, Java), izvairoties no serializācijas un deserializācijas kļūdām.
• Uzturējamība un noturība: Validētas datu struktūras uzlabo izsekojamību un samazina grūti diagnosticējamu kļūdu iespējamību konfigurācijas failos, žurnālfailos vai API pieprasījumos/atbildēs.
• Privātums un drošība: Validācija var tikt veikta pilnībā klienta pusē (pārlūkprogrammā), novēršot neapstrādātu vai sensitīvu datu iziešanu no lietotāja ierīces validācijai.

Biežākās JSON validācijas kļūdas (ar detalizētiem piemēriem)

Atslēgas bez pēdiņām

Visiem atslēgvārdiem JSON objektos jābūt dubultiekavās iekļautām virknes formāta vērtībām.

{ name: "Alise" }

{ "name": "Alise" }

Daudzi JSON līdzīgi formāti (piemēram, JavaScript objektu literāli) atļauj atslēgām būt bez pēdiņām, taču standarta JSON tā nedara.

Vienkāršie pēdiņi

JSON virknes jālieto tikai divkāršās pēdiņas; vienkāršās pēdiņas nav atļautas.

{ 'name': 'Bobs' }

{ "vārds": "Bobs" }

Vienkāršu pēdiņu lietošana izraisīs parsēšanas kļūdas visās saderīgajās JSON bibliotēkās.

Beigu komati

Pēdējā elementa pēc objekta vai masīva nav liekas komata.

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

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

Beigu komati var darboties JavaScript, bet ne stingros JSON analizatoros.

Nepareiza rakstzīmju aizsardzība

Pēdiņas un speciālie rakstzīmes iekš virknes jāizceļ, izmantojot atpakaļsvītru.

{ "quote": "Toms teica \"sveiki\"" }

{ "quote": "Toms teica \"čau\"" }

Citas izvēršanās secības ietver \\ kā atpakaļsvītru, \n jaunu rindu un \t tabulēšanas simboliem.

Nepareizi datu tipi

Virknes nedrīkst izmantot numuriem, loģiskajām vērtībām vai nullēm.

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

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

JSON atšķir booleānus, skaitļus un virknes — nodrošiniet pareiza datu tipa izmantošanu.

Neprimārie Atslēgas

JSON objekta atslēgām vienmēr jābūt virknei; nevar izmantot skaitļus, loģiskās vērtības vai citus datu tipus kā atslēgas.

{ 123: "abc" }

{ "123": "abc" }

Dublikātu atslēgas

Lai gan JSON specifikācija to atļauj, dublikātu atslēgas ir biežs kļūdu avots.

{ "name": "Alise", "name": "Bobs" }

Lielākā daļa analizatoru saglabās tikai pēdējo vērtību ("Bobs"), klusējot izslēdzot agrākās.

Komentāru izmantošana

Standarta JSON nesatur komentārus, pat ja daži redaktori tos atbalsta.

{
  // Lietotāja informācija
  "name": "Alise"
}

{
  "name": "Alise"
}

Shēmu validācija: struktūras un datu tipu nodrošināšana

JSON shēma ir jaudīgs standarts JSON dokumentu paredzamās struktūras definēšanai un validēšanai. Tā ļauj jums norādīt:

• Obligātie lauki (`required`)
• Datu tipi (`type`: virkne, skaitlis, loģiskais, objekts, masīvs, null)
• Teksta formāti (`format`: e-pasts, uuid, datums-un-laiks u.c.)
• Rakstu saskaņošana virkņu meklēšanai (`pattern`)
• Skaitļu diapazoni (`minimums`, `maksimums`)
• Masīva garuma un elementu validācija (`minItems`, `maxItems`, `items`)
• Iekšējā validācija objektiem un masīviem
• Enum vērtību ierobežojumi (`enum`)

Piemērs: Lietotāja shēma (Draft-07)

{
  "type": "objekts",
  "properties": {
    "id":    { "type": "virkne", "format": "uuid" },
    "name":  { "type": "virkne", "minLength": 1 },
    "email": { "type": "virkne", "format": "e-pasts" },
    "is_active": { "type": "loģiska vērtība" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Ko tas nodrošina:

• ID jābūt derīgam UUID virknei.
• vārds nedrīkst būt tukšs teksts.
• epasta adrese jāatbilst standarta epasta formātam.
• is_active (pēc izvēles) jābūt patiesības vērtībai.
• Nav atļautas citas īpašības kā tikai augstāk definētās.

Reāls piemērs: Stripe API atbilžu validācija

Pieņemsim, ka saņemat JSON atbildes no Stripe API (piemēram, PaymentIntent). Shēmas validācija nodrošina, ka jūs nekad neapstrādājat nepilnīgus vai nepareizi tipētus datus.

{
  "type": "objekts",
  "properties": {
    "id":      { "type": "virkne", "pattern": "^pi_" },
    "object":  { "type": "virkne", "const": "maksājuma_nodoms" },
    "amount":  { "type": "vesels_skaitlis", "minimum": 1 },
    "currency":{ "type": "virkne", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "virkne", "enum": [
      "prasa_maksājuma_metodi",
      "prasa_apstiprinājumu",
      "apstrādē",
      "izdevies",
      "atcelts"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• ID jāiet sākas ar "pi_"
• objektam vienmēr jābūt "payment_intent"
• summai jābūt veselam skaitlim, kas ir vienāds vai lielāks par 1
• valūta jābūt trīs burtu virknei (piemēram, "usd", "eur")
• statusam jābūt vienam no norādītajām vērtībām

Priekšrocības

• Agrīna kļūdu atklāšana: Identificējiet būtiskas API izmaiņas vai nepilnīgus datus pirms tie nonāk jūsu biznesa loģikā.
• Automatizētā testēšana: Izmantojiet shēmas CI/CD plūsmās, lai pārbaudītu gan reālas, gan simulētas atbildes.
• Komandu savstarpējā konsekvence: standartizējiet datu līgumus starp frontend, backend un trešo personu API.

Pareiza JSON validācija — aptver gan sintaksi, gan shēmu — novērš smalkas kļūdas, nodrošina labākās prakses ievērošanu un aizsargā jūsu lietojumprogrammas no nekorektiem vai ļaunprātīgiem datiem. Neatkarīgi no tā, vai tā tiek izmantota konfigurācijas failos, API datu plūsmās vai starp pakalpojumu saziņā, stingra validācija ir mūsdienīgu programmatūras sistēmu pamatā.

Privātums un drošība

Visas validācijas un shēmas pārbaudes tiek veiktas lokāli jūsu pārlūkprogrammā. Dati netiek augšupielādēti vai saglabāti. Jūsu JSON paliek pilnībā privāts.

Koda piemēri JSON validācijai

Uzziniet, kā pārbaudīt JSON dažādās programmēšanas valodās, izmantojot iebūvētās bibliotēkas vai populārus rīkus. Šie piemēri parāda gan sintakses pārbaudi, gan shēmas validāciju.

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

Par šo rīku