JSON Validator

Wat is JSON-validatie?

JSON (JavaScript Object Notation) is een breed toegepast, lichtgewicht formaat voor gegevensuitwisseling, ontworpen om zowel menselijk leesbaar te zijn als eenvoudig te verwerken en te genereren door machines. Het belangrijkste doel is het gestructureerd weergeven van data—objecten, arrays, tekststrings, getallen, booleans en null-waarden—op een taalonafhankelijke manier.

JSON-validatie is het proces waarbij een JSON-document programmatisch wordt gecontroleerd om te bevestigen dat het zowel syntactisch als structureel correct is. Dit omvat het controleren van twee belangrijke aspecten:

• Syntactische Validatie: Zorgen dat de ruwe tekst voldoet aan de formele grammatica zoals gedefinieerd in de ECMA-404 JSON-specificatie. Parsers in de meeste moderne programmeertalen (bijvoorbeeld JSON.parse() in JavaScript, json.loads() in Python, JSONDecoder in Java) verwachten geldige syntaxis en geven fouten als de invoer incorrect is.
• Structurele (Schema) Validatie: Naast de syntaxis controleert schema-validatie of de JSON-gegevens overeenkomen met een verwachte structuur, inclusief gegevens typen, verplichte eigenschappen, waarde beperkingen en geneste objecten/arrays. Schema-validatie wordt doorgaans uitgevoerd met JSON Schema, dat regels definieert voor wat als geldige data wordt beschouwd.

Waarom JSON Valideren?

JSON-validatie is cruciaal wanneer gegevens worden geserialiseerd voor overdracht, opslag of communicatie tussen diensten. Belangrijke redenen zijn:

• Foutpreventie: Identificeer en rapporteer syntaxisfouten (bijv. ontbrekende komma's, niet-gesloten haakjes, ongeldige tekens) vroegtijdig—voordat je gegevens gaat verwerken.
• Gegevensintegriteit & Beveiliging: Weiger onjuiste of kwaadaardige JSON-payloads, ter voorkoming van backend crashes, injectieaanvallen en datacorruptie.
• Typeveiligheid: Zorg voor strikte typetoepassing—waardoor bijvoorbeeld een veld dat een boolean moet zijn niet als een string wordt verzonden, en UUID's, e-mails of nummers het juiste formaat volgen.
• Taaloverschrijdende Compatibiliteit: Zorg ervoor dat JSON die in één omgeving wordt aangemaakt (bijvoorbeeld Node.js) probleemloos kan worden gebruikt in een andere omgeving (zoals Python, Go, Java), en voorkom daarmee fouten bij serialisatie en deserialisatie.
• Onderhoudbaarheid & Robuustheid: Gevalideerde datastructuren verbeteren de traceerbaarheid en verkleinen het risico op moeilijk te debuggen fouten in configuratiebestanden, logs of API-aanvragen/-responses.
• Privacy en Veiligheid: Validatie kan volledig aan de clientzijde (in de browser) worden uitgevoerd, waardoor ruwe of gevoelige gegevens het apparaat van de gebruiker niet verlaten voor validatie.

Veelvoorkomende JSON-validatiefouten (met gedetailleerde voorbeelden)

Ongeciteerde sleutels

Alle sleutels in JSON-objecten moeten dubbel-geviseerde strings zijn.

{ naam: "Alice" }

{ "name": "Alice" }

Veel JSON-achtige formaten (bijv. JavaScript-objectliteralnotatie) staan ongenoteerde sleutels toe, maar standaard JSON doet dat niet.

Enkele aanhalingstekens

JSON-strings moeten alleen dubbele aanhalingstekens gebruiken; enkele aanhalingstekens zijn niet toegestaan.

{ 'naam': 'Bob' }

{ "name": "Bob" }

Het gebruik van enkele aanhalingstekens zal leiden tot parserfouten in alle conforme JSON-bibliotheken.

Achtervoegende komma's

Geen afsluitende komma na het laatste item in een object of array.

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

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

Achtervoegende komma's kunnen werken in JavaScript, maar niet in strikte JSON-parsers.

Onjuiste Escaping van Tekens

Aanhalingstekens en speciale tekens binnen strings moeten worden ontsnapt met een omgekeerde schuine streep (backslash).

{ "quote": "Tom zei \"hallo\"" }

{ "quote": "Tom zei \"hallo\"" }

Andere escape-tekens zijn onder andere \\ voor backslash, \n voor nieuwe regels en \t voor tabs.

Onjuiste Gegevenstypen

Strings mogen niet worden gebruikt voor getallen, booleans of null waarden.

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

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

JSON maakt onderscheid tussen booleans, getallen en strings—zorg ervoor dat het juiste type wordt gebruikt.

Niet-Primitieve Sleutels

JSON-object-sleutels moeten altijd strings zijn; je kunt geen nummers, booleans of andere typen als sleutels gebruiken.

{ 123: "abc" }

{ "123": "abc" }

Duplicaat Sleutels

Hoewel toegestaan door de JSON-specificatie, zijn dubbele sleutels een veelvoorkomende oorzaak van fouten.

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

De meeste parsers bewaren alleen de laatste waarde ("Bob") en negeren eerdere waarden zonder melding.

Gebruik van Reacties

Standaard JSON staat geen opmerkingen toe, hoewel sommige editors dit wel ondersteunen.

{
  // Gebruikersinformatie
  "name": "Alice"
}

{
  "name": "Alice"
}

Schema-validatie: Structuur en datatypes afdwingen

JSON Schema is een krachtig standaard voor het definiëren en valideren van de verwachte structuur van JSON-documenten. Het stelt je in staat om te specificeren:

• Verplichte velden (`required`)
• Gegevenstypen (`type`: string, nummer, boolean, object, array, null)
• Tekenreeksformaten (`format`: e-mail, uuid, datum-tijd, enz.)
• Patroonherkenning voor strings (`pattern`)
• Numerieke bereiken (`minimum`, `maximum`)
• Arraylengte en itemvalidatie (`minItems`, `maxItems`, `items`)
• Geneste validatie voor objecten en arrays
• Enum-beperkingen (`enum`)

Voorbeeld: Gebruikersschema (Concept-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
}

Wat dit afdwingt:

• id moet een geldige UUID-string zijn.
• naam moet een niet-lege tekenreeks zijn.
• e-mailadres moet voldoen aan het standaard e-mailformaat.
• is_active (optioneel) moet een boolean zijn.
• Geen andere eigenschappen dan hierboven gedefinieerd zijn toegestaan.

Praktijkvoorbeeld: Validatie van Stripe API Responsen

Stel dat je JSON-antwoorden ontvangt van de Stripe API (bijvoorbeeld PaymentIntent). Schema-validatie zorgt ervoor dat je nooit onvolledige of verkeerd getypeerde gegevens verwerkt.

{
  "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": [
      "vereist_betaalmethode",
      "vereist_bevestiging",
      "verwerking",
      "geslaagd",
      "geannuleerd"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id moet beginnen met "pi_"
• object moet altijd "payment_intent" zijn
• hoeveelheid moet een geheel getal zijn, groter dan of gelijk aan 1
• valuta moet een drieletterige string zijn (bijv. "usd", "eur")
• status moet een van de opgegeven waarden zijn

Voordelen

• Vroege Foutdetectie: Ontdek ingrijpende API-wijzigingen of onvolledige gegevens voordat ze je bedrijfslogica bereiken.
• Geautomatiseerd Testen: Gebruik schema's in CI/CD-pijplijnen om echte en gesimuleerde responsen te valideren.
• Consistentie tussen teams: Standaardiseer datacontracten tussen frontend, backend en API's van derden.

Correcte JSON-validatie—zowel van syntaxis als schema—voorkomt subtiele fouten, handhaaft best practices en beveiligt uw applicaties tegen foutieve of kwaadwillige invoer. Of het nu wordt gebruikt in configuratiebestanden, API-payloads of communicatie tussen diensten, robuuste validatie vormt de basis van moderne softwaresystemen.

Privacy & Beveiliging

Alle validatie- en schema-controles worden lokaal in je browser uitgevoerd. Er worden geen gegevens geüpload of opgeslagen. Je JSON blijft volledig privé.

Voorbeelden van code voor JSON-validatie

Bekijk hoe je JSON kunt valideren in verschillende programmeertalen met ingebouwde libraries of populaire frameworks. Deze voorbeelden tonen zowel syntaxisvalidatie als schema-validatie.

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

Over deze tool