json_decode

(PHP 5 >= 5.2.0, PHP 7, PHP 8, PECL json >= 1.2.0)

json_decodeDekodiert eine JSON-Zeichenkette

Beschreibung

json_decode(
    string $json,
    ?bool $associative = null,
    int $depth = 512,
    int $flags = 0
): mixed

Konvertiert eine JSON-kodierte Zeichenkette in einen PHP-Wert.

Parameter-Liste

json

Der zu dekodierende json-String.

Diese Funktion funktioniert nur mit Zeichenketten, die UTF-8-kodiert sind.

Hinweis:

PHP implementiert eine Obermenge von JSON wie im Original » RFC 7159 beschrieben.

associative

Wenn true, werden JSON-Objekte als assoziative Arrays zurückgegeben. Wenn false, werden JSON-Objekte als Objekte zurückgegeben. Wenn null, werden JSON-Objekte als assoziative Arrays oder Objekte zurückgegeben, abhängig davon, ob JSON_OBJECT_AS_ARRAY in den flags gesetzt ist.

depth

Die maximale Verschachtelungstiefe der zu dekodierenden Struktur. Der Wert muss größer als 0 sein und kleiner als oder gleich 2147483647.

flags

Eine Bitmaske von JSON_BIGINT_AS_STRING, JSON_INVALID_UTF8_IGNORE, JSON_INVALID_UTF8_SUBSTITUTE, JSON_OBJECT_AS_ARRAY, JSON_THROW_ON_ERROR. Das Verhalten dieser Konstanten ist auf der Seite über die JSON-Konstanten beschrieben.

Rückgabewerte

Gibt den in json kodierten Wert als entsprechenden PHP-Typ zurück. Ohne Anführungszeichen werden die Werte true, false und null als true, false bzw. null zurückgegeben. Wenn json nicht dekodiert werden kann oder wenn die kodierten Daten tiefer verschachtelt sind, als es der Parameter für Verschachtelungstiefe erlaubt, wird null zurückgegeben.

Fehler/Exceptions

Wenn depth außerhalb des erlaubten Bereichs liegt, wird ab PHP 8.0.0 ein ValueError ausgelöst, während vorher ein Fehler der Stufe E_WARNING ausgelöst wurde.

Changelog

Version Beschreibung
7.3.0 Die flags-Konstante JSON_THROW_ON_ERROR wurde hinzugefügt.
7.2.0 associative ist nun ein Nullable-Typ.
7.2.0 Die flags-Konstanten JSON_INVALID_UTF8_IGNORE und JSON_INVALID_UTF8_SUBSTITUTE wurden hinzugefügt.
7.1.0 Ein leerer JSON-Schlüssel ("") kann als leere Objekt-Eigenschaft kodiert werden, anstatt einen Schlüssel mit dem Wert _empty_ zu verwenden.

Beispiele

Beispiel #1 json_decode()-Beispiele

<?php
$json
= '{"a":1,"b":2,"c":3,"d":4,"e":5}';

var_dump(json_decode($json));
var_dump(json_decode($json, true));

?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

object(stdClass)#1 (5) {
    ["a"] => int(1)
    ["b"] => int(2)
    ["c"] => int(3)
    ["d"] => int(4)
    ["e"] => int(5)
}

array(5) {
    ["a"] => int(1)
    ["b"] => int(2)
    ["c"] => int(3)
    ["d"] => int(4)
    ["e"] => int(5)
}

Beispiel #2 Zugriff auf ungültige Objekteigenschaften

Auf Elemente von Objekten, die Zeichen enthalten, welche gemäß den Namenskonventionen von PHP nicht gültig sind (z. B. der Bindestrich), kann durch ein Umschließen des Namens mit geschweiften Klammern und einfachen Anführungszeichen zugegriffen werden.

<?php

$json
= '{"foo-bar": 12345}';

$obj = json_decode($json);
print
$obj->{'foo-bar'}; // 12345

?>

Beispiel #3 Häufige Fehler bei der Verwendung von json_decode()

<?php

// die folgenden Zeichenketten sind gültiges JavaScript aber kein gültiges JSON

// der Name und der Wert müssen in doppelten Anführungszeichen eingeschlossen werden
// einfache Anführungszeichen sind ungültig
$bad_json = "{ 'bar': 'baz' }";
json_decode($bad_json); // null

// der Name muss in doppelten Anführungszeichen eingeschlossen werden
$bad_json = '{ bar: "baz" }';
json_decode($bad_json); // null

// nachfolgende Kommata sind nicht erlaubt
$bad_json = '{ bar: "baz", }';
json_decode($bad_json); // null

?>

Beispiel #4 Fehler bei der Verwendung von depth

<?php
// Einige Daten mit einer maximalen Tiefe von 4
// (array -> array -> array -> string) kodieren
$json = json_encode(
array(
1 => array(
'englisch' => array(
'One',
'January'
),
'französisch' => array(
'Une',
'Janvier'
)
)
)
);

// Die Fehler für unterschiedliche Verschachtelungstiefen anzeigen.
var_dump(json_decode($json, true, 4));
echo
'Letzter Fehler: ', json_last_error_msg(), PHP_EOL, PHP_EOL;

var_dump(json_decode($json, true, 3));
echo
'Letzter Fehler: ', json_last_error_msg(), PHP_EOL, PHP_EOL;
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(1) {
  [1]=>
  array(2) {
    ["English"]=>
    array(2) {
      [0]=>
      string(3) "One"
      [1]=>
      string(7) "January"
    }
    ["French"]=>
    array(2) {
      [0]=>
      string(3) "Une"
      [1]=>
      string(7) "Janvier"
    }
  }
}
Letzter Fehler: No error

NULL
Letzter Fehler: Maximum stack depth exceeded

Beispiel #5 json_decode() von großen Ganzzahlen

<?php
$json
= '{"number": 12345678901234567890}';

var_dump(json_decode($json));
var_dump(json_decode($json, false, 512, JSON_BIGINT_AS_STRING));

?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

object(stdClass)#1 (1) {
  ["number"]=>
  float(1.2345678901235E+19)
}
object(stdClass)#1 (1) {
  ["number"]=>
  string(20) "12345678901234567890"
}

Anmerkungen

Hinweis:

Die JSON-Spezifikation ist kein JavaScript, sondern eine Teilmenge davon.

Hinweis:

Tritt ein Dekodierungsfehler auf, kann json_last_error() verwendet werden, um die exakte Art des Fehlers zu ermitteln.

Siehe auch

add a note

User Contributed Notes 4 notes

up
22
Lennart Hengstmengel
2 years ago
JSON can be decoded to PHP arrays by using the $associative = true option. Be wary that associative arrays in PHP can be a "list" or "object" when converted to/from JSON, depending on the keys (of absence of them).

You would expect that recoding and re-encoding will always yield the same JSON string, but take this example:

$json = '{"0": "No", "1": "Yes"}';
$array = json_decode($json, true); // decode as associative hash
print json_encode($array) . PHP_EOL;

This will output a different JSON string than the original:

["No","Yes"]

The object has turned into an array!

Similarly, a array that doesn't have consecutive zero based numerical indexes, will be encoded to a JSON object instead of a list.

$array = [
'first',
'second',
'third',
];
print json_encode($array) . PHP_EOL;
// remove the second element
unset($array[1]);
print json_encode($array) . PHP_EOL;

The output will be:

["first","second","third"]
{"0":"first","2":"third"}

The array has turned into an object!

In other words, decoding/encoding to/from PHP arrays is not always symmetrical, or might not always return what you expect!

On the other hand, decoding/encoding from/to stdClass objects (the default) is always symmetrical.

Arrays may be somewhat easier to work with/transform than objects. But especially if you need to decode, and re-encode json, it might be prudent to decode to objects and not arrays.

If you want to enforce an array to encode to a JSON list (all array keys will be discarded), use:

json_encode(array_values($array));

If you want to enforce an array to encode to a JSON object, use:

json_encode((object)$array);

See also: https://www.php.net/manual/en/function.array-is-list.php
up
2
greaties at ghvernuft dot nl
1 year ago
To load an object with data in json format:
(bugfixed my previous comment)

<?php
function loadJSON($Obj, $json)
{
$dcod = json_decode($json);
$prop = get_object_vars ( $dcod );
foreach(
$prop as $key => $lock)
{
if(
property_exists ( $Obj , $key ))
{
if(
is_object($dcod->$key))
{
loadJSON($Obj->$key, json_encode($dcod->$key));
}
else
{
$Obj->$key = $dcod->$key;
}
}
}
return
$Obj;
}
?>

Tested with:

<?php
class Name
{
public
$first;
public
$last;
public function
fullname()
{
return
$this->first . " " . $this->last;
}
}
$json = '{"first":"John","last":"Smith"}';

$infull = loadJSON((new Name), $json);
echo
$infull->fullname();
up
4
cubefox at web dot NOSPAMPLEASE dot de
3 years ago
Warning: As the section "return values" mentions, the return value NULL is ambiguos. To repeat, it can mean three things:

* The input string had the value "null"
* There was an error while parsing the input data
* The encoded data was deeper than the recursion limit

To distinguish these cases, json_last_error() can be used.
up
3
Alien426
3 years ago
Browsers don't choke on integers _starting_ with BigInt (64 bits), but before that (53 bits). The introduction of BigInt to modern browsers doesn't help much, when JSON handling functions do not support it. So I am trying to remedy that. My approach is to handle the decoded array before re-encoding it to a string:
<?php
function fix_large_int(&$value)
{
if (
is_int($value) && $value > 9007199254740991)
$value = strval($value);
}
$json_str = '{"id":[1234567890123456789,12345678901234567890]}';
$json_arr = json_decode($json_str, flags: JSON_BIGINT_AS_STRING | JSON_OBJECT_AS_ARRAY);
echo(
json_encode($json_arr)); // {"id":[1234567890123456789,"12345678901234567890"]} (BigInt is already converted to a string here)
array_walk_recursive($json_arr, 'fix_large_int');
echo(
json_encode($json_arr)); // {"id":["1234567890123456789","12345678901234567890"]}
?>
To Top