JSON für Entwickler: Syntax, Validierung und häufige Fehler

· 12 Min. Lesezeit

Inhaltsverzeichnis

Was ist JSON und warum es wichtig ist

JSON (JavaScript Object Notation) hat sich zum De-facto-Standard für den Datenaustausch im Web entwickelt. Trotz des Namens, der eine JavaScript-Verbindung nahelegt, ist JSON vollständig sprachunabhängig und wird von praktisch jeder modernen Programmiersprache unterstützt.

Ursprünglich von Douglas Crockford in den frühen 2000er Jahren spezifiziert, entstand JSON als leichtgewichtige Alternative zu XML. Seine Einfachheit und menschliche Lesbarkeit machten es zum perfekten Format für APIs, Konfigurationsdateien und Datenspeicherung.

Heute treibt JSON alles an, von REST-APIs und NoSQL-Datenbanken bis hin zu Konfigurationsdateien und Datenpipelines. JSON gründlich zu verstehen ist nicht nur hilfreich – es ist essentiell für moderne Softwareentwicklung.

Kurztipp: JSON ist keine Programmiersprache oder ein Datenbankformat. Es ist rein ein Datenserialisierungsformat – eine Möglichkeit, strukturierte Daten als Text darzustellen.

JSON-Syntaxregeln

Die Syntax von JSON ist täuschend einfach, aber ihre Strenge überrascht viele Entwickler. Im Gegensatz zu JavaScript-Objekten hat JSON null Toleranz für Syntaxvariationen.

Hier ist ein gültiges JSON-Beispiel, das die Kernstruktur demonstriert:

{
  "name": "RunDev",
  "version": 2,
  "features": ["formatter", "validator", "converter"],
  "config": {
    "theme": "dark",
    "autoSave": true
  },
  "deprecated": null
}

Die nicht verhandelbaren Regeln

Jedes JSON-Dokument muss diesen strikten Regeln folgen:

Warum so streng?

Die Strenge von JSON ist beabsichtigt. Durch die Eliminierung von Mehrdeutigkeiten stellt JSON sicher, dass jedes gültige JSON-Dokument auf allen Plattformen und Sprachen identisch geparst werden kann. Diese Vorhersagbarkeit macht JSON zuverlässig für den Datenaustausch.

Das Fehlen von Kommentaren wird oft kritisiert, aber es zwingt Entwickler dazu, ihre Daten durch klare Schlüsselnamen und Struktur selbstdokumentierend zu machen. Für Konfigurationsdateien, bei denen Kommentare benötigt werden, sollten Sie JSONC (JSON with Comments) oder JSON5 in Betracht ziehen.

Profi-Tipp: Verwenden Sie unseren JSON-Formatierer, um häufige Syntaxfehler automatisch zu beheben und sicherzustellen, dass Ihr JSON vor der Bereitstellung gültig ist.

JSON-Datentypen verstehen

JSON unterstützt genau sechs Datentypen. Dieser begrenzte Satz hält das Format einfach und deckt gleichzeitig die meisten Anforderungen an die Datendarstellung ab.

Typ Beispiel Hinweise
String "hello world" Muss in doppelte Anführungszeichen gesetzt werden. Unterstützt Escape-Sequenzen: \n, \t, \u0041, \", \\
Number 42, 3.14, -1, 1e10 Keine Unterscheidung zwischen Integer und Float. Kein Hex, Oktal oder spezielle Werte wie Infinity
Boolean true, false Nur Kleinbuchstaben. "true" ist ein String, kein Boolean
Null null Nur Kleinbuchstaben. Repräsentiert beabsichtigte Abwesenheit eines Wertes
Array [1, "two", true] Geordnete Liste. Kann gemischte Typen enthalten (obwohl homogene Arrays klarer sind)
Object {"key": "value"} Ungeordnete Schlüssel-Wert-Paare. Schlüssel müssen Strings sein und sollten eindeutig sein

Strings und Escape-Sequenzen

JSON-Strings unterstützen mehrere Escape-Sequenzen für Sonderzeichen:

Mehrzeilige Strings müssen Escape-Sequenzen verwenden – wörtliche Zeilenumbrüche sind nicht erlaubt:

{
  "correct": "Zeile 1\nZeile 2\nZeile 3",
  "incorrect": "Zeile 1
Zeile 2
Zeile 3"
}

Zahlen: Was erlaubt ist und was nicht

JSON-Zahlen sind restriktiver als die meisten Programmiersprachen:

Die JSON-Spezifikation definiert keine Präzisionsgrenzen, aber die meisten Implementierungen verwenden IEEE 754 Gleitkommazahlen mit doppelter Genauigkeit, was bedeutet, dass Ganzzahlen bis zu 2^53 - 1 (9.007.199.254.740.991) sicher sind.

Profi-Tipp: Für große Ganzzahlen jenseits von JavaScripts sicherem Ganzzahlbereich sollten Sie erwägen, sie als Strings zu speichern, um Präzisionsverlust beim Parsing zu verhindern.

Objekte und Schlüsseleinzigartigkeit

Während die JSON-Spezifikation besagt, dass Objektschlüssel eindeutig sein sollten, schreibt sie nicht vor, wie Parser mit Duplikaten umgehen sollen. Verschiedene Implementierungen verhalten sich unterschiedlich:

Best Practice: Stellen Sie immer sicher, dass Ihre Schlüssel eindeutig sind, um unvorhersehbares Verhalten über verschiedene Parser hinweg zu vermeiden.

Häufige Fehler und wie man sie vermeidet

Selbst erfahrene Entwickler machen JSON-Syntaxfehler. Hier sind die häufigsten Fehler und ihre Korrekturen:

Fehler Falsch Richtig
Einfache Anführungszeichen {'name': 'test'} {"name": "test"}
Abschließendes Komma {"a": 1, "b": 2,} {"a": 1, "b": 2}
Nicht in Anführungszeichen gesetzte Schlüssel {name: "test"} {"name": "test"}
Kommentare {"a": 1 // comment} Kommentare entfernen oder JSONC verwenden
Undefined-Wert {"a": undefined} {"a": null}
Führende Nullen {"port": 080} {"port": 80}
Wörtliche Zeilenumbrüche "line1
line2"		 "line1\nline2"
Funktionswerte {"fn": function(){}} Nicht unterstützt – Strings verwenden oder umstrukturieren

Die JavaScript-Objekt-Falle

Die größte Quelle von JSON-Fehlern ist, es wie JavaScript-Objektliteralsyntax zu behandeln. Sie sehen ähnlich aus, haben aber kritische Unterschiede:

// Gültiges JavaScript-Objekt
const jsObj = {
  name: 'test',        // nicht in Anführungszeichen gesetzter Schlüssel, einfache Anführungszeichen
  age: 30,
  active: true,
  getData: function() { return this.name; },  // Funktionen erlaubt
  // Kommentar erlaubt
};

// Gültiges JSON (als String)
const jsonStr = `{
  "name": "test",
  "age": 30,
  "active": true
}`;

Denken Sie daran: JSON ist ein Datenformat, kein Code. Es kann keine Funktionen, Kommentare oder ausführbare Logik enthalten.

Zeichenkodierungsprobleme

JSON muss in UTF-8, UTF-16 oder UTF-32 kodiert sein. UTF-8 ist die gebräuchlichste und empfohlene Kodierung. Achten Sie auf:

Kurztipp: Fügen Sie Ihr JSON in unseren JSON-Validator ein, um sofort Syntaxfehler, Kodierungsprobleme und strukturelle Probleme zu identifizieren.

JSON validieren: Tools und Techniken

Validierung ist entscheidend, um Fehler zu erkennen, bevor sie Laufzeitfehler verursachen. So validieren Sie JSON in verschiedenen Umgebungen.

Befehlszeilen-Validierung

Schnelle Validierung mit integrierten Tools:

# Python (integriert, überall verfügbar)
python3 -m json.tool data.json

# Schön formatieren und validieren
python3 -m json.tool data.json output.json

# jq (leistungsstarker JSON-Prozessor)
jq . data.json

# jq mit Fehlerdetails
jq . data.json || echo "Ungültiges JSON"

# Node.js Einzeiler
node -e "console.log(JSON.parse(require('fs').readFileSync('data.json')))"

# jsonlint verwenden (über npm installieren)
jsonlint data.json

Programmatische Validierung

JSON in Ihrem Anwendungscode validieren:

// JavaScript/Node.js
function isValidJSON(str) {
  try {
    JSON.parse(str);
    return true;
  } catch (e) {
    console.error('JSON-Fehler:', e.message);
    return false;
  }
}

# Python
import json

def is_valid_json(json_str):
    try:
        json.loads(json_str)
        return True
    except json.JSONDecodeError as e:
        print(f'JSON-Fehler: {e}')
        return False

// Go
import "encoding/json"

func isValidJSON(data []byte) bool {
    var js json.RawMessage
    return json.Unmarshal(data, &js) == nil
}

Schema-Validierung

Syntaxvalidierung prüft nur, ob JSON wohlgeformt ist. Schema-Validierung stellt sicher, dass die Datenstruktur und -typen Ihren Anforderungen entsprechen.

JSON Schema ist der Standard zur Definition von JSON-Strukturen:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1
    },
    "age": {
      "type": "integer",
      "minimum": 0,
      "maximum": 150
    },
    "email": {
      "type": "string",
      "format": "email"
    }
  },
  "required": ["name", "email"]
}

Beliebte Schema-Validierungsbibliotheken:

Profi-Tipp: Verwenden Sie unseren JSON-Schema-Validator, um Ihre Schemas gegen Beispieldaten zu testen, bevor Sie sie im Code implementieren.

Online-Validierungstools

Für schnelle Überprüfungen während der Entwicklung:

Best Practices für Parsing und Serialisierung

Parsing konvertiert JSON-Text in native Datenstrukturen. Serialisierung macht das Gegenteil. Beide Operationen haben Auswirkungen auf Leistung und Sicherheit.

Sichere Parsing-Praktiken

Umschließen Sie JSON-Parsing immer mit Fehlerbehandlung:

// JavaScript - Basis-Parsing
try {
  const data = JSON.parse(jsonString);
  // Daten verwenden
} catch (error) {
  console.error('JSON-Parsing fehlgeschlagen:', error.message);
  // Fehler angemessen behandeln
}

// JavaScript - Mit Reviver-Funktion
const data = JSON.parse(jsonString, (key, value) => {
  // Datumsangaben aus Strings transformieren
  if (key.endsWith('Date') && typeof value === 'string') {
    return new Date(value);
  }
  return value;
});

Best Practices für Serialisierung

Kontrollieren Sie, wie Objekte in JSON konvertiert werden:

// JavaScript - Basis-Serialisierung
const json = JSON.stringify(data);

// Schön formatiert mit Einrückung
const json = JSON.stringify(data, null, 2);

// Benutzerdefinierte Serialisierung mit Replacer
const json = JSON.stringify(data, (key, value) => {
  // Sensible Felder entfernen
  if (key === 'password' || key === 'apiKey') {
    return undefined;
  }
  // BigInt in String konvertieren
  if (typeof value === 'bigint'