PHP Decodifica una stringa JSON


Esempio

La funzione json_decode() accetta una stringa con codifica JSON come suo primo parametro e la analizza in una variabile PHP.

Normalmente, json_decode() restituirà un oggetto di \ stdClass se l'elemento di livello superiore nell'oggetto JSON è un dizionario o un array indicizzato se l'oggetto JSON è un array. Restituirà anche valori scalari o NULL per determinati valori scalari, come stringhe semplici, "true" , "false" e "null" . Restituisce anche NULL su qualsiasi errore.

// Returns an object (The top level item in the JSON string is a JSON dictionary)
$json_string = '{"name": "Jeff", "age": 20, "active": true, "colors": ["red", "blue"]}';
$object = json_decode($json_string);
printf('Hello %s, You are %s years old.', $object->name, $object->age);
#> Hello Jeff, You are 20 years old.

// Returns an array (The top level item in the JSON string is a JSON array)
$json_string = '["Jeff", 20, true, ["red", "blue"]]';
$array = json_decode($json_string);
printf('Hello %s, You are %s years old.', $array[0], $array[1]);

Utilizzare var_dump() per visualizzare i tipi e i valori di ogni proprietà sull'oggetto decodificato in precedenza.

// Dump our above $object to view how it was decoded
var_dump($object);

Uscita (notare i tipi di variabile):

class stdClass#2 (4) {
 ["name"] => string(4) "Jeff"
 ["age"] => int(20)
 ["active"] => bool(true)
 ["colors"] =>
   array(2) {
     [0] => string(3) "red"
     [1] => string(4) "blue"
   }
}

Nota: i tipi di variabile in JSON sono stati convertiti nel loro equivalente PHP.


Per restituire un array associativo per oggetti JSON invece di restituire un oggetto, passare true come secondo parametro a json_decode() .

$json_string = '{"name": "Jeff", "age": 20, "active": true, "colors": ["red", "blue"]}';
$array = json_decode($json_string, true); // Note the second parameter
var_dump($array);

Output (notare la struttura associativa dell'array):

array(4) {
  ["name"] => string(4) "Jeff"
  ["age"] => int(20)
  ["active"] => bool(true)
  ["colors"] =>
  array(2) {
    [0] => string(3) "red"
    [1] => string(4) "blue"
  }
}

Il secondo parametro ( $assoc ) non ha alcun effetto se la variabile da restituire non è un oggetto.

Nota: se si utilizza il parametro $assoc , si perde la distinzione tra una matrice vuota e un oggetto vuoto. Ciò significa che l'esecuzione di json_encode() sull'output decodificato risulterà in una diversa struttura JSON.

Se la stringa JSON ha una "profondità" superiore a 512 elementi ( 20 elementi nelle versioni precedenti alla 5.2.3 o 128 nella versione 5.2.3 ) in ricorsione, la funzione json_decode() restituisce NULL . Nelle versioni 5.3 o successive, questo limite può essere controllato usando il terzo parametro ( $depth ), come discusso di seguito.


Secondo il manuale:

PHP implementa un superset di JSON come specificato nell'originale »RFC 4627 - codificherà e decodificherà anche i tipi scalari e NULL. RFC 4627 supporta solo questi valori quando sono nidificati all'interno di un array o di un oggetto. Sebbene questo superset sia coerente con la definizione ampliata di "testo JSON" nel nuovo »RFC 7159 (che mira a sostituire RFC 4627) e » ECMA-404 , ciò potrebbe causare problemi di interoperabilità con parser JSON più vecchi che aderiscono strettamente a RFC 4627 quando codifica di un singolo valore scalare.

Ciò significa che, ad esempio, una stringa semplice sarà considerata come un oggetto JSON valido in PHP:

$json = json_decode('"some string"', true);
var_dump($json, json_last_error_msg());

Produzione:

string(11) "some string"
string(8) "No error"

Ma le stringhe semplici, non in un array o in un oggetto, non fanno parte dello standard RFC 4627 . Di conseguenza, tali controllori online come JSLint , JSON Formatter & Validator (in modalità RFC 4627) ti daranno un errore.

Esiste un terzo parametro $depth per la profondità della ricorsione (il valore predefinito è 512 ), che significa la quantità di oggetti nidificati all'interno dell'oggetto originale da decodificare.

C'è un quarto parametro $options . Attualmente accetta solo un valore, JSON_BIGINT_AS_STRING . Il comportamento predefinito (che abbandona questa opzione) consiste nel trasmettere interi grandi a float anziché stringhe.

Le varianti non minuscole non valide dei letterali true, false e null non sono più accettate come input valido.

Quindi questo esempio:

var_dump(json_decode('tRue'), json_last_error_msg());
var_dump(json_decode('tRUe'), json_last_error_msg());
var_dump(json_decode('tRUE'), json_last_error_msg());
var_dump(json_decode('TRUe'), json_last_error_msg());
var_dump(json_decode('TRUE'), json_last_error_msg());
var_dump(json_decode('true'), json_last_error_msg());

Prima di PHP 5.6:

bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"

E dopo:

NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
bool(true)
string(8) "No error"

Comportamento simile si verifica per false e null .

Si noti che json_decode() restituirà NULL se la stringa non può essere convertita.

$json = "{'name': 'Jeff', 'age': 20 }" ;  // invalid json 

$person = json_decode($json);
echo $person->name;    //  Notice: Trying to get property of non-object: returns null
echo json_last_error();     
#  4 (JSON_ERROR_SYNTAX)
echo json_last_error_msg(); 
#  unexpected character 

Non è sicuro affidarsi solo al valore restituito NULL per rilevare errori. Ad esempio, se la stringa JSON non contiene altro che "null" , json_decode() restituirà null , anche se non si è verificato alcun errore.