Ob eine eingehende Zeichenkette überhaupt gültiges JSON ist, lässt sich seit PHP 8.3 in einer einzigen Zeile beantworten. Die Funktion json_validate() prüft die Syntax, ohne den Wert erst aufwendig in PHP-Strukturen zu übersetzen. Dieses Tutorial erklärt die Signatur, den Performance-Vorteil gegenüber json_decode(), den Parameter max_depth und einen Polyfill für ältere Versionen.
Was leistet PHP json_validate?
Mit PHP json_validate steht seit PHP 8.3 eine Funktion bereit, die rein prüft, ob ein JSON-String syntaktisch korrektes JSON enthält. Sie liefert einen Boolean, ohne den Wert in eine PHP-Datenstruktur zu übersetzen, und ist damit deutlich schneller und speicherschonender als der klassische Umweg über json_decode() mit anschließender Fehlerprüfung. Anwendungsfälle reichen vom kurzen Sanity-Check vor dem eigentlichen Parsen bis zum Bouncer-Endpunkt, der nur gültige Payloads in eine Queue weiterreicht.
Bevor Syntax, max_depth und der Polyfill an die Reihe kommen, lohnt ein kurzer Blick auf den Performance-Gewinn gegenüber json_decode.
Dieses Tutorial erklärt die Syntax, beleuchtet den Performance-Vorteil, geht auf den Parameter max_depth zur Abwehr zu tief verschachtelter JSON-Bomben ein und zeigt einen Polyfill, mit dem auch ältere PHP-Versionen die gleiche API nutzen können. Am Ende steht eine klare Empfehlung, wann json_validate() die richtige Wahl ist und wann json_decode() mit JSON_THROW_ON_ERROR der elegantere Weg bleibt.
Syntax und Rückgabewert von PHP json_validate
Die Signatur ist kurz und einprägsam. PHP json_validate erwartet einen JSON-String und akzeptiert optional eine maximale Verschachtelungstiefe sowie einen reservierten Flag-Parameter, der aktuell noch keine Funktion hat.
<?php
json_validate(string $json, int $depth = 512, int $flags = 0): bool
Der Rückgabewert ist immer true oder false. Bei einem ungültigen Input liefert die Funktion false, ohne eine Exception zu werfen oder eine Warning auszugeben. Wer den genauen Fehler braucht, kann anschließend json_last_error() und json_last_error_msg() aufrufen, sie werden von json_validate() mit aktualisiert.
<?php
$gueltig = '{"name": "Mia", "alter": 30}';
$kaputt = '{"name": "Mia", "alter": 30';
var_dump(json_validate($gueltig));
/* bool(true) */
var_dump(json_validate($kaputt));
/* bool(false) */
echo json_last_error_msg();
/* Syntax error */
Wann ist PHP json_validate schneller als json_decode?
PHP json_validate hat einen klaren Performance-Vorteil. Der Performance-Vorteil ergibt sich, weil json_validate() keinen vollständigen Wert im Speicher aufbaut. Beim klassischen Pattern json_decode() plus json_last_error() muss PHP erst alle Strings, Arrays und Objekte instanziieren, bevor das Programm prüfen kann, ob alles in Ordnung war. Wer den Wert dann doch nicht braucht, hat für nichts gearbeitet.
<?php
$payload = file_get_contents('php://input');
if (!json_validate($payload)) {
http_response_code(400);
exit('Ungueltiger JSON-Body.');
}
$daten = json_decode($payload, true);
/* sicher dekodieren, weil syntaktisch ok */
echo 'Empfangen: ' . $daten['name'];
Praktisch lohnt sich der Aufruf vor allem in zwei Szenarien. Erstens: Webhook-Endpunkte, die nur die Gültigkeit prüfen und das Original danach in eine Datei oder Queue ablegen. Zweitens: Validierungs-Layer in einer API, die Hunderte von Requests pro Sekunde abfertigen und nur in einem Bruchteil der Fälle den vollen Wert weiterverarbeiten. In beiden Fällen entfällt der teure Speicheraufbau, und der Server bleibt entspannt.
Der Parameter max_depth bei PHP json_validate
JSON ist eine baumartige Struktur, die theoretisch beliebig tief verschachtelt sein kann. Eine böswillige Eingabe mit ein paar Millionen geöffneten Klammern kann den Parser sprengen. Der Parameter max_depth setzt eine Obergrenze. Standardwert ist 512, was für reale Daten ausreicht, für Angriffe aber nicht.
<?php
/* Konstruiert ein zu tiefes JSON */
$tief = str_repeat('[', 600) . str_repeat(']', 600);
var_dump(json_validate($tief));
/* bool(false) - Standard-Tiefe ist 512 */
var_dump(json_validate($tief, 700));
/* bool(true) - mit erhoehter Tiefe */
Wer Daten aus untrusted-Quellen akzeptiert, sollte den Default belassen oder sogar auf 100 oder 50 reduzieren, je nach erwartetem Schema. Wer hingegen tief verschachtelte interne Konfigurationsdateien parst, kann die Grenze gezielt anheben. Eine kleine Faustregel: Lieber abbrechen, als unbegrenzt rechnen lassen.
Polyfill für PHP json_validate auf Versionen vor 8.3
PHP json_validate steht erst ab PHP 8.3 nativ bereit. Wer noch auf PHP 8.0, 8.1 oder 8.2 unterwegs ist, kann die gleiche API trotzdem nutzen. Eine kurze function_exists-Prüfung am Bootstrap-Anfang genügt, um einen Fallback zu definieren. So kann der Anwendungs-Code einheitlich bleiben.
<?php
if (!function_exists('json_validate')) {
function json_validate(string $json, int $depth = 512, int $flags = 0): bool
{
json_decode($json, true, $depth, $flags);
return json_last_error() === JSON_ERROR_NONE;
}
}
var_dump(json_validate('{"ok": true}'));
/* bool(true) */
Der Polyfill verzichtet auf den Performance-Vorteil, weil er intern doch json_decode() aufruft. Aber der API-Vorteil bleibt: Anwendungs-Code muss nicht zwischen Versionen unterscheiden, und sobald der Server auf PHP 8.3 aktualisiert wird, greift automatisch die schnelle native Variante. Mehr zu solchen Bootstrap-Patterns gibt es im Tutorial zu defined() und konditionalen Konstanten.
Der grundlegende Ablauf einer JSON-Prüfung mit anschließendem Dekodieren lässt sich in wenigen Schritten darstellen.
flowchart TD
A[Eingabe-String] --> B{json_validate}
B -->|true| C[json_decode bei Bedarf]
B -->|false| D[Fehlerbehandlung HTTP 400]
C --> E[Datenstruktur weiterverarbeiten]
PHP json_validate vs JSON-Schema
PHP json_validate hat klare Grenzen, die man kennen sollte. Wichtig zu wissen: json_validate() prüft nur die Syntax. Ob die enthaltenen Daten den fachlichen Erwartungen entsprechen, etwa "muss ein Feld email enthalten und der Wert muss eine Zeichenkette sein", ist nicht Teil der Prüfung. Für diesen Fall gibt es JSON-Schema und das Composer-Paket justinrainbow/json-schema, das gegen ein fachliches Schema validiert.
<?php
/* erst Syntax pruefen */
if (!json_validate($payload)) {
exit('Syntax-Fehler im JSON.');
}
/* dann fachliche Struktur (Beispiel pseudocodiert) */
$schema = json_decode(file_get_contents('user-schema.json'));
$daten = json_decode($payload);
$validator = new JsonSchema\Validator();
$validator->validate($daten, $schema);
if (!$validator->isValid()) {
foreach ($validator->getErrors() as $fehler) {
echo $fehler['message'] . PHP_EOL;
}
}
Diese Trennung in Syntax-Check und Schema-Check ist sauber und schnell. Der schnelle json_validate()-Aufruf filtert offensichtlichen Müll aus, der teure Schema-Validator bekommt nur Eingaben, die zumindest syntaktisch in Ordnung sind. Wer eine REST-API mit PHP baut, kann diesen Zwei-Stufen-Ansatz als Standard-Validierungs-Layer einsetzen.
Praktische Anwendungsfälle PHP json_validate
Drei typische Patterns tauchen immer wieder auf. Erstens: ein Webhook-Endpunkt, der eingehende Daten nur in eine Datei schreibt und dann per Cron-Job verarbeitet. Hier reicht json_validate() plus file_put_contents(), kein Decode nötig.
<?php
$payload = file_get_contents('php://input');
if (!json_validate($payload)) {
http_response_code(400);
exit('Ungueltiger JSON-Body.');
}
$datei = __DIR__ . '/queue/' . uniqid('webhook_', true) . '.json';
file_put_contents($datei, $payload);
http_response_code(202);
echo 'OK';
Zweitens: ein Pre-Filter vor einer Schema-Validierung, wie im vorherigen Abschnitt gezeigt. Drittens: ein Logging-Endpunkt, der eingehende JSON-Logs nur akzeptiert, wenn sie mindestens valides JSON sind, ohne den fachlichen Inhalt vorab zu prüfen. Wer den Wert dann doch braucht, sollte überlegen, gleich json_decode() mit JSON_THROW_ON_ERROR zu nutzen, weil ein zweiter Parser-Aufruf doppelte Arbeit wäre. Der bessere Weg sieht in diesem Fall so aus.
<?php
try {
$daten = json_decode($payload, true, 512, JSON_THROW_ON_ERROR);
echo 'Name: ' . $daten['name'];
} catch (JsonException $e) {
http_response_code(400);
echo 'Fehler: ' . $e->getMessage();
}
Im Webhook-Pfad gilt grundsätzlich: erst json_validate() als billiger Vorpruefer, dann json_decode() mit JSON_THROW_ON_ERROR an genau einer Stelle, an der die Datenstruktur tatsächlich gebraucht wird. So bleibt der Hot-Path schlank und es wird nicht doppelt geparst.
Fazit zu PHP json_validate
PHP json_validate ist eine kleine, aber feine Erweiterung in PHP 8.3. Sie nimmt dem Validierungs-Code Speicher und Zeit ab, ohne dass sich die API verkompliziert. Das passende Pattern ist klar: Wer nur wissen will, ob ein Input syntaktisch gültig ist, ruft json_validate() auf. Wer den Wert anschließend braucht, nimmt direkt json_decode() mit JSON_THROW_ON_ERROR. Mit einem kleinen Polyfill bleibt der Code auch in älteren PHP-Versionen einheitlich. Für Schema-Validierung bleibt die Funktion ein Komplement, kein Ersatz, sodass bei strukturellen Anforderungen weiter ein dediziertes JSON-Schema-Paket gebraucht wird.
