JSON-validaattori

Mitä JSON-validointi tarkoittaa?

JSON (JavaScript Object Notation) on laajalti käytetty, kevyt tiedonvaihtoformaatti, joka on suunniteltu sekä ihmisen luettavaksi että koneiden helposti jäsennettäväksi ja tuotettavaksi. Sen pääasiallinen tarkoitus on esittää jäsenneltyjä tietoja—objekteja, taulukoita, merkkijonoja, lukuja, totuusarvoja ja null-arvoja—kieliriippumattomalla tavalla.

JSON-validointi on prosessi, jossa ohjelmallisesti varmistetaan, että JSON-dokumentti on sekä syntaksiltaan että rakenteeltaan oikea. Tämä sisältää kahden pääasiallisen osa-alueen tarkistamisen:

• Syntaksin tarkistus: Varmistetaan, että raakatieto noudattaa ECMA-404 JSON-spesifikaation määrittelemää virallista kielioppia. Useimpien nykyaikaisten ohjelmointikielien jäsentimet (esim. JSON.parse() JavaScriptissä, json.loads() Pythonissa, JSONDecoder Javassa) odottavat kelvollista syntaksia ja antavat virheilmoituksia, jos syöte on virheellisesti muodostettu.
• Rakenteellinen (skeema) validointi: Syntaksin lisäksi skeeman validointi tarkistaa, että JSON-data vastaa odotettua rakennetta, mukaan lukien tietotyypit, vaaditut ominaisuudet, arvorajoitukset sekä sisäkkäiset objektit ja taulukot. Skeeman validointi suoritetaan yleensä JSON Schema -määritelmän avulla, joka määrittää säännöt pätevälle datalle.

Miksi validoida JSON?

JSON:n validointi on ratkaisevan tärkeää aina, kun dataa sarjoitetaan siirtoa, tallennusta tai palveluiden välistä viestintää varten. Keskeiset syyt ovat:

• Virheiden estäminen: Tunnista ja ilmoita syntaksivirheistä (esim. puuttuvat pilkut, virheelliset sulkeet, laittomat merkit) ajoissa—ennen datan käsittelyä.
• Tietojen eheys ja turvallisuus: Hylkää virheelliset tai haitalliset JSON-datakuormat, estäen palvelinvirheet, injektiohyökkäykset ja tietojen vioittumisen.
• Tyyppiturvallisuus: Varmista tiukka tyypitys—esimerkiksi ettei kenttää, jonka odotetaan olevan totuusarvo, lähetetä merkkijonona, tai että UUID:t, sähköpostit ja numerot noudattavat oikeaa muotoa.
• Kielirajat ylittävä yhteensopivuus: Varmista, että yhdessä ympäristössä (esim. Node.js) tuotettu JSON voidaan turvallisesti käyttää toisessa (esim. Python, Go, Java) ilman sarjallistamis- tai desarjallistamisvirheitä.
• Ylläpidettävyys ja Vankkuus: Vahvistetut tietorakenteet parantavat jäljitettävyyttä ja vähentävät vaikeasti virheenkorjattavien virheiden riskiä konfiguraatiotiedostoissa, lokitiedoissa sekä API-pyynnöissä ja -vastauksissa.
• Tietosuoja ja turvallisuus: Vahvistus voidaan suorittaa kokonaan asiakaspuolella (selaimessa), mikä estää raakadatana tai arkaluontoisen tiedon lähtemisen käyttäjän laitteelta vahvistusta varten.

Yleiset JSON-validointivirheet (yksityiskohtaiset esimerkit)

Tarpeettomat lainausmerkit avaimissa

Kaikkien JSON-objektien avainten tulee olla kaksoislainausmerkeillä ympäröityjä merkkijonoja.

{ name: "Alice" }

{ "name": "Alice" }

Monet JSONia muistuttavat formaatit (esim. JavaScript-objektin literaalit) sallivat lainausmerkeillä merkitsemättömät avaimet, mutta standardi JSON ei.

Yksittäiset lainausmerkit

JSON-merkkijonojen on käytettävä vain kaksoislainausmerkkejä; yksittäisiä lainausmerkkejä ei sallita.

{ 'nimi': 'Bob' }

{ "name": "Bob" }

Yksittäisten lainausmerkkien käyttö aiheuttaa jäsentäjävirheitä kaikissa JSON-yhteensopivissa kirjastoissa.

Peräkkäiset pilkut

Älä käytä pilkkua lopetusmerkkinä objektin tai taulukon viimeisen kohteen jälkeen.

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

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

Vinoviivat voivat toimia JavaScriptissä, mutta eivät tiukoissa JSON-jäsentimissä.

Merkkien virheellinen pakoitus

Lainausmerkit ja erikoismerkit merkkijonojen sisällä on poistettava käyttämällä kauttaviivaa (backslash).

{ "quote": "Tom sanoi \"hei\"" }

{ "quote": "Tom sanoi \"hei\"" }

Muita erikoismerkkejä ovat \\ käänteinen kenoviiva, \n rivinvaihdot ja \t sarkaimet varten.

Virheelliset tietotyypit

Merkkijonoja ei tulisi käyttää lukujen, totuusarvojen tai null-arvojen sijaan.

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

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

JSON eroaa totuusarvojen, lukujen ja merkkijonojen välillä—varmista, että käytät oikeaa tietotyyppiä.

Ei-primitiiviset avaimet

JSON-olion avaimet ovat aina merkkijonoja; et voi käyttää numeroita, totuusarvoja tai muita tyyppejä avaimina.

{ 123: "abc" }

{ "123": "abc" }

Kaksoisavaimet

Vaikka JSON-määritelmä sen sallii, duplikaattien avaimien esiintyminen on yleinen virhelähde.

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

Suurin osa jäsentäjistä säilyttää vain viimeisen arvon (”Bob”) ja hylkää aiemmat hiljaisesti.

Kommenttien käyttö

Standardi JSON ei salli kommentteja, vaikka jotkin editorit tukevatkin niitä.

{
  // Käyttäjätiedot
  "name": "Alice"
}

{
  "name": "Alice"
}

Skeeman validointi: rakenteen ja tietotyyppien varmistaminen

JSON Schema on tehokas standardi, jonka avulla voit määritellä ja validoida JSON-tiedostojen odotetun rakenteen. Sen avulla voit määrittää:

• Pakolliset kentät (`required`)
• Tietotyypit (`type`: merkkijono, numero, totuusarvo, objekti, taulukko, null)
• Merkkijonojen muodot (`format`: sähköposti, uuid, päivämäärä-aika, jne.)
• Merkkijonojen kaaviontunnistus (`pattern`)
• Numerovälit (`vähimmäis`, `enimmäis`)
• Taulukon pituuden ja kohteiden validointi (`minItems`, `maxItems`, `items`)
• Sisäkkäinen validointi objekteille ja taulukoille
• Enum-rajoitukset (`enum`)

Esimerkki: Käyttäjän skeema (Luonnos-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1, "description": "Nimi" },
    "email": { "type": "string", "format": "email", "description": "Sähköpostiosoite" },
    "is_active": { "type": "boolean", "description": "Onko aktiivinen" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Mitä tämä edistää:

• tunnuksen on oltava kelvollinen UUID-merkkijono.
• nimen on oltava ei-tyhjä merkkijono.
• sähköpostiosoitteen on oltava standardin mukaisessa muodossa.
• is_active (valinnainen) tulee olla totuusarvo (boolean).
• Muita ominaisuuksia kuin yllä määritellyt ei sallita.

Todellinen esimerkki: Stripe API -vastausten validointi

Oletetaan, että vastaanotat JSON-vastauksia Stripe API:lta (esim. PaymentIntent). Skeeman validointi varmistaa, ettei koskaan käsittele puutteellisia tai väärin tyypitettyjä tietoja.

{
  "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": [
      "vaatii_maksutavan",
      "vaatii_vahvistuksen",
      "käsitellään",
      "onnistui",
      "peruttu"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• ID:n on aloitettava merkkijonolla "pi_"
• olio on aina oltava "payment_intent"
• määrän on oltava kokonaisluku, joka on yhtä suuri tai suurempi kuin 1
• valuutan tulee olla kolmen kirjaimen merkkijono (esim. "usd", "eur")
• tila on oltava yksi määritellyistä arvoista

Edut

• Varhainen virheiden tunnistus: Havaitse kriittiset API-muutokset tai puutteelliset tiedot ennen kuin ne vaikuttavat liiketoimintalogiikkaasi.
• Automaattinen testaus: Käytä skeemoja CI/CD-putkistoissa todellisten ja mallivastausten validoimiseen.
• Tiimien välinen yhtenäisyys: Standardisoi dataratkaisut frontendin, backendin ja kolmansien osapuolien API-rajapintojen välillä.

Oikea JSON-validointi—joka kattaa sekä syntaksin että skeeman—estää hienovaraiset virheet, noudattaa parhaita käytäntöjä ja suojaa sovelluksesi virheellisiltä tai haitallisilta syötteiltä. Olipa kyse sitten konfiguraatiotiedostoista, API-tiedoista tai palveluiden välisistä viesteistä, tehokas validointi on nykyaikaisten ohjelmistojärjestelmien perusta.

Tietosuoja & Turvallisuus

Kaikki validointi- ja skeematarkistukset suoritetaan paikallisesti selaimessasi. Tietoja ei ladata tai tallenneta. JSON-tiedostosi pysyy täysin yksityisenä.

Koodiesimerkit JSON-validointiin

Katso, kuinka JSON-tiedoston validointi suoritetaan eri ohjelmointikielillä sisäänrakennettujen kirjastojen tai suosittujen kehysten avulla. Nämä esimerkit näyttävät sekä syntaksin validoinnin että skeeman validoinnin.

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

Tietoa tästä työkalusta