PHP json_decode(): JSON in Arrays oder Objekte umwandeln

json_decode($json, true) macht aus einem JSON-String PHP-Werte, mit jedem JSON-Objekt als assoziativem Array. Lass true weg, dann werden JSON-Objekte stattdessen zu stdClass-Objekten, die du mit -> liest. Ungültiges JSON ergibt null.

<?php
$json = '{"name": "Ada", "age": 36, "langs": ["php", "js"], "admin": true}';

$data = json_decode($json, true);   // associative array
echo $data['name'], "\n";
echo $data['langs'][1], "\n";

$obj = json_decode($json);          // stdClass object
echo $obj->name, "\n";
echo $obj->langs[0], "\n";

print_r($data);

Ausgabe:

Ada
js
Ada
php
Array
(
    [name] => Ada
    [age] => 36
    [langs] => Array
        (
            [0] => php
            [1] => js
        )

    [admin] => 1
)

JSON-Arrays werden immer zu PHP-Listen, egal welchen Modus du wählst. Die andere Richtung, von PHP zu JSON, ist json_encode().

Assoziatives Array oder Objekt: true vs false

Beide Modi enthalten dieselben Daten; wähl den, der sich in deinem Code besser liest. Arrays funktionieren mit jeder Array-Funktion (array_column, array_map, isset($data['key'])), deshalb übergeben die meisten true. Objekte brauchen die Klammersyntax für Schlüssel, die keine gültigen Eigenschaftsnamen sind, etwa Schlüssel mit Bindestrich oder Zahlen:

<?php
$json = '{"first-name": "Ada", "0": "zero", "address": {"city": "London"}}';

$arr = json_decode($json, true);
echo $arr['first-name'], ' ', $arr[0], ' ', $arr['address']['city'], "\n";

$obj = json_decode($json);
echo $obj->{'first-name'}, ' ', $obj->{'0'}, ' ', $obj->address->city, "\n";

var_dump($obj->address);

Ausgabe:

Ada zero London
Ada zero London
object(stdClass)#2 (1) {
  ["city"]=>
  string(6) "London"
}

Der vierte Parameter nimmt Flags. JSON_OBJECT_AS_ARRAY liefert ebenfalls Arrays, aber nur, solange das zweite Argument null ist (sein Standardwert): json_decode($json, flags: JSON_OBJECT_AS_ARRAY) liefert Arrays, während json_decode($json, false, 512, JSON_OBJECT_AS_ARRAY) weiterhin Objekte liefert.

Über verschachteltes JSON iterieren

API-Antworten sind meist eine Liste von Objekten in einem Objekt. Dekodiere einmal, lauf dann mit foreach durch und verwende ?? für Felder, die fehlen könnten:

<?php
$json = <<<'JSON'
{
    "page": 1,
    "users": [
        {"id": 1, "name": "Ada", "email": "ada@example.com", "roles": ["admin", "editor"]},
        {"id": 2, "name": "Linus", "roles": []},
        {"id": 3, "name": "Grace", "email": "grace@example.com", "roles": ["editor"]}
    ]
}
JSON;

$data = json_decode($json, true);

foreach ($data['users'] as $user) {
    $email = $user['email'] ?? 'no email';
    $roles = $user['roles'] ? implode(', ', $user['roles']) : 'none';
    echo "#{$user['id']} {$user['name']} <$email> roles: $roles\n";
}

$names = array_column($data['users'], 'name', 'id');
print_r($names);

Ausgabe:

#1 Ada <ada@example.com> roles: admin, editor
#2 Linus <no email> roles: none
#3 Grace <grace@example.com> roles: editor
Array
(
    [1] => Ada
    [2] => Linus
    [3] => Grace
)

Ungültiges JSON behandeln

json_decode() liefert null für ungültiges JSON, aber null ist auch das korrekte Ergebnis für den JSON-Text null, also verrät null allein nicht, ob es gescheitert ist. json_last_error_msg() nennt den Grund des letzten Aufrufs. Der sauberere Weg ist JSON_THROW_ON_ERROR, das eine JsonException wirft:

<?php
var_dump(json_decode('{"a": 1,}'));   // trailing comma
echo json_last_error_msg(), "\n";

var_dump(json_decode('null'));        // valid JSON, also null
echo json_last_error_msg(), "\n";

try {
    $data = json_decode("{'a': 1}", true, 512, JSON_THROW_ON_ERROR);
} catch (JsonException $e) {
    echo 'Invalid JSON: ', $e->getMessage(), "\n";
}

Ausgabe:

NULL
Syntax error
NULL
No error
Invalid JSON: Syntax error

Das dritte Argument, 512, ist die maximale Verschachtelungstiefe (der Standard). Mit benannten Argumenten kannst du es überspringen: json_decode($json, true, flags: JSON_THROW_ON_ERROR).

Mit json_validate() prüfen, ob ein String gültiges JSON ist

PHP 8.3 brachte json_validate(). Es antwortet mit true oder false, ohne die dekodierten Arrays aufzubauen, und braucht deshalb weniger Speicher als das Dekodieren, wenn du nur ein Ja oder Nein brauchst, etwa um einen Request-Body früh abzulehnen:

<?php
$inputs = ['{"a": 1}', '[1, 2, 3]', '"text"', '{a: 1}', "{'a': 1}", ''];

foreach ($inputs as $input) {
    $ok = json_validate($input) ? 'valid' : 'invalid: ' . json_last_error_msg();
    echo str_pad(var_export($input, true), 14), $ok, "\n";
}

Ausgabe:

'{"a": 1}'    valid
'[1, 2, 3]'   valid
'"text"'      valid
'{a: 1}'      invalid: Syntax error
'{\'a\': 1}'  invalid: Syntax error
''            invalid: Syntax error

Wenn du die Daten sowieso verwendest, lass json_validate() weg und dekodiere mit JSON_THROW_ON_ERROR: Vorher zu validieren parst den String zweimal.

Eine JSON-Datei lesen

Lies die Datei mit file_get_contents() und dekodiere den String. Dieser Block schreibt zuerst settings.json, damit es eine Datei zum Lesen gibt:

<?php
file_put_contents('settings.json', '{"theme": "dark", "fontSize": 14, "plugins": ["git", "lint"]}');

$text = file_get_contents('settings.json');
if ($text === false) {
    exit("Cannot read settings.json\n");
}

$settings = json_decode($text, true, flags: JSON_THROW_ON_ERROR);
echo "Theme: {$settings['theme']}\n";
echo "Plugins: ", count($settings['plugins']), "\n";

// Change a value and write the file back
$settings['fontSize'] = 16;
file_put_contents('settings.json', json_encode($settings, JSON_PRETTY_PRINT));
echo file_get_contents('settings.json'), "\n";

Ausgabe:

Theme: dark
Plugins: 2
{
    "theme": "dark",
    "fontSize": 16,
    "plugins": [
        "git",
        "lint"
    ]
}

Warum json_decode null liefert: die üblichen Ursachen

JSON ist strenger als JavaScript und als die Array-Syntax von PHP. Jeder String unten sieht vernünftig aus, und jeder liefert null. Führe es aus, um den Grund für jeden zu sehen, korrigiere dann einen und führe es erneut aus:

<?php
$cases = [
    'single quotes'   => "{'name': 'Ada'}",
    'unquoted key'    => '{name: "Ada"}',
    'trailing comma'  => '{"name": "Ada",}',
    'comment'         => '{"name": "Ada" /* admin */}',
    'byte order mark' => "\xEF\xBB\xBF" . '{"name": "Ada"}',
    'too deep'        => '[[["Ada"]]]',
];

foreach ($cases as $label => $json) {
    $depth = $label === 'too deep' ? 2 : 512;
    $result = json_decode($json, true, $depth);
    echo str_pad($label, 17), $result === null ? json_last_error_msg() : 'ok', "\n";
}

// Big integers lose precision unless you ask for strings
var_dump(json_decode('{"id": 12345678901234567890}', true)['id']);
var_dump(json_decode('{"id": 12345678901234567890}', true, 512, JSON_BIGINT_AS_STRING)['id']);

Ausgabe:

single quotes    Syntax error
unquoted key     Syntax error
trailing comma   Syntax error
comment          Syntax error
byte order mark  Syntax error
too deep         Maximum stack depth exceeded
float(1.2345678901234567E+19)
string(20) "12345678901234567890"

Eine Byte Order Mark ist in den meisten Editoren unsichtbar und der klassische Grund, warum eine JSON-Datei „gut aussieht“, sich aber nicht dekodieren lässt. Entferne sie vor dem Dekodieren mit $text = preg_replace('/^\xEF\xBB\xBF/', '', $text);.