JSON-Validator

Was ist JSON-Validierung?

JSON (JavaScript Object Notation) ist ein weitverbreitetes, leichtgewichtiges Format zum Datenaustausch, das darauf ausgelegt ist, sowohl für Menschen gut lesbar als auch für Maschinen einfach zu verarbeiten und zu erzeugen zu sein. Sein Hauptzweck besteht darin, strukturierte Daten — Objekte, Arrays, Zeichenketten, Zahlen, Booleans und Nullwerte — sprachunabhängig darzustellen.

Die JSON-Validierung ist der Prozess der programmatischen Überprüfung, ob ein JSON-Dokument sowohl syntaktisch als auch strukturell korrekt ist. Dabei werden zwei Hauptaspekte geprüft:

• Syntaktische Validierung: Sicherstellung, dass der Rohtext der formalen Grammatik gemäß der ECMA-404 JSON-Spezifikation entspricht. Parser in den meisten modernen Programmiersprachen (z. B. JSON.parse() in JavaScript, json.loads() in Python, JSONDecoder in Java) erwarten eine gültige Syntax und lösen Fehler aus, wenn die Eingabe fehlerhaft ist.
• Strukturelle (Schema-)Validierung: Über die Syntax hinaus überprüft die Schema-Validierung, ob die JSON-Daten einer erwarteten Struktur entsprechen, einschließlich Datentypen, erforderlicher Eigenschaften, Wertbeschränkungen sowie verschachtelter Objekte und Arrays. Die Schema-Validierung wird in der Regel mit JSON Schema durchgeführt, das Regeln definiert, welche Daten als gültig gelten.

Warum JSON validieren?

JSON-Validierung ist entscheidend, wenn Daten für die Übertragung, Speicherung oder die Kommunikation zwischen Diensten serialisiert werden. Wichtige Gründe sind:

• Fehlervermeidung: Erkennen und Melden von Syntaxfehlern (z. B. fehlende Kommas, nicht übereinstimmende Klammern, unzulässige Zeichen) frühzeitig – bevor die Datenverarbeitung erfolgt.
• Datenintegrität & Sicherheit: Ablehnung von fehlerhaften oder bösartigen JSON-Nutzlasten zur Vermeidung von Backend-Abstürzen, Injektionsangriffen und Datenbeschädigungen.
• Typsicherheit: Strikte Typprüfung durchsetzen – zum Beispiel sicherstellen, dass ein Feld, das als Boolean erwartet wird, nicht als Zeichenfolge gesendet wird oder dass UUIDs, E-Mail-Adressen und Zahlen das korrekte Format einhalten.
• Sprachübergreifende Kompatibilität: Stellen Sie sicher, dass in einer Umgebung (z. B. Node.js) erzeugte JSON-Daten problemlos und fehlerfrei in einer anderen Umgebung (z. B. Python, Go, Java) verwendet werden können, um Probleme bei der Serialisierung und Deserialisierung zu vermeiden.
• Wartbarkeit & Robustheit: Validierte Datenstrukturen verbessern die Nachvollziehbarkeit und verringern das Risiko schwer nachvollziehbarer Fehler in Konfigurationsdateien, Protokollen sowie API-Anfragen und -Antworten.
• Datenschutz & Sicherheit: Die Validierung kann vollständig clientseitig (im Browser) durchgeführt werden, wodurch verhindert wird, dass Rohdaten oder sensible Informationen das Gerät des Nutzers für die Überprüfung verlassen.

Häufige JSON-Validierungsfehler (mit ausführlichen Beispielen)

Unquoted-Schlüssel

Alle Schlüssel in JSON-Objekten müssen als doppelt umschlossene Strings angegeben werden.

{ name: "Alice" }

{ "name": "Alice" }

Viele JSON-ähnliche Formate (z. B. JavaScript-Objektliterale) erlauben ungequotete Schlüssel, aber standardmäßiges JSON tut dies nicht.

Einfache Anführungszeichen

JSON-Zeichenketten müssen ausschließlich doppelte Anführungszeichen verwenden; einfache Anführungszeichen sind nicht erlaubt.

{ 'name': 'Bob' }

{ "name": "Bob" }

Die Verwendung von einfachen Anführungszeichen führt in allen konformen JSON-Bibliotheken zu Parserfehlern.

Nachgestellte Kommata

Kein abschließendes Komma nach dem letzten Element in einem Objekt oder Array.

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

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

Nachgestellte Kommata funktionieren in JavaScript, jedoch nicht in strengen JSON-Parsern.

Unsachgemäße Maskierung von Zeichen

Anführungszeichen und Sonderzeichen innerhalb von Zeichenketten müssen mit einem Rückwärtsschrägstrich (Backslash) maskiert werden.

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

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

Weitere Escape-Sequenzen umfassen \\ für den Rückwärtsschrägstrich, \n für neue Zeilen und \t für Tabulatoren.

Falsche Datentypen

Zeichenketten sollten nicht für Zahlen, Wahrheitswerte oder Null verwendet werden.

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

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

JSON unterscheidet zwischen Booleschen Werten, Zahlen und Zeichenketten – stellen Sie sicher, dass der richtige Typ verwendet wird.

Nicht-primitiven Schlüsseln

JSON-Objektschlüssel müssen immer Zeichenketten sein; Sie können keine Zahlen, Booleschen Werte oder andere Typen als Schlüssel verwenden.

{ 123: "abc" }

{ "123": "abc" }

Doppelte Schlüssel

Obwohl im JSON-Standard erlaubt, sind doppelte Schlüssel eine häufige Fehlerquelle.

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

Die meisten Parser behalten nur den letzten Wert („Bob“) und verwerfen zuvor eingegebene Werte stillschweigend.

Verwendung von Kommentaren

Standard-JSON erlaubt keine Kommentare, obwohl einige Editoren sie unterstützen.

{
  // Benutzerinformationen
  "name": "Alice"
}

{
  "name": "Alice"
}

Schema-Validierung: Struktur- und Datentypenprüfung für maximale Datengenauigkeit

JSON Schema ist ein leistungsstarker Standard zur Definition und Validierung der erwarteten Struktur von JSON-Dokumenten. Damit können Sie festlegen:

• Pflichtfelder (`required`)
• Datentypen (`type`: Zeichenfolge, Zahl, Wahrheitswert, Objekt, Array, Null)
• Zeichenkettenformate (`format`: E-Mail, UUID, Datum-Uhrzeit, usw.)
• Mustererkennung für Zeichenketten (`pattern`)
• Zahlenbereiche (`Mindestwert`, `Höchstwert`)
• Array-Länge und Elementvalidierung (`minItems`, `maxItems`, `items`)
• Verschachtelte Validierung für Objekte und Arrays
• Enum-Einschränkungen (`enum`)

Beispiel: Benutzerschema (Entwurf-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
}

Was dies durchsetzt:

• Die ID muss ein gültiger UUID-String sein.
• Der Name muss eine nicht-leere Zeichenkette sein.
• Die E-Mail muss dem Standard-E-Mail-Format entsprechen.
• is_active (optional) muss ein boolescher Wert sein.
• Keine anderen Eigenschaften als die oben definierten sind erlaubt.

Praxisbeispiel: Validierung von Stripe API-Antworten

Angenommen, Sie erhalten JSON-Antworten von der Stripe-API (z. B. PaymentIntent). Eine Schema-Validierung stellt sicher, dass Sie niemals unvollständige oder falsch typisierte Daten verarbeiten.

{
  "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": [
      "erfordert_zahlungsmethode",
      "erfordert_bestaetigung",
      "wird_verarbeitet",
      "erfolgreich",
      "abgebrochen"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• Die ID muss mit "pi_" beginnen
• Objekt muss immer "payment_intent" sein
• Der Betrag muss eine ganze Zahl größer oder gleich 1 sein
• Währung muss ein dreibuchstabiger Code sein (z. B. "usd", "eur")
• Status muss einer der angegebenen Werte sein

Vorteile

• Frühe Fehlererkennung: Entdecken Sie kritische API-Änderungen oder unvollständige Daten, bevor sie Ihre Geschäftslogik beeinträchtigen.
• Automatisiertes Testen: Verwenden Sie Schemata in CI/CD-Pipelines, um reale und simulierte Antworten zu validieren.
• Bereichsübergreifende Konsistenz: Standardisieren Sie Datenverträge zwischen Frontend, Backend und Drittanbieter-APIs.

Eine korrekte JSON-Validierung—einschließlich Syntax- und Schema-Überprüfung—verhindert subtile Fehler, gewährleistet bewährte Praktiken und schützt Ihre Anwendungen vor fehlerhaften oder bösartigen Eingaben. Ob in Konfigurationsdateien, API-Daten oder der Kommunikation zwischen Diensten eingesetzt, ist eine zuverlässige Validierung die Grundlage moderner Softwaresysteme.

Datenschutz & Sicherheit

Alle Validierungs- und Schemaprüfungen erfolgen lokal in Ihrem Browser. Es werden keine Daten hochgeladen oder protokolliert. Ihr JSON bleibt vollkommen privat.

Code-Beispiele zur JSON-Validierung

Erfahren Sie, wie Sie JSON in verschiedenen Programmiersprachen mithilfe integrierter Bibliotheken oder gängiger Frameworks validieren. Diese Beispiele zeigen sowohl die Syntaxprüfung als auch die Schema-Validierung.

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

Über dieses Tool