JSON è uno dei formati di interscambio dati fra applicazioni client/server più utilizzati. JSON non è un array, un oggetto o una struttura dati. JSON è un formato di serializzazione basato su testo, quindi una stringa di fantasia, ma pur sempre solo una stringa.
Può essere decodificato in PHP usando json_decode().
$data = json_decode($json);
All’interno di un file JSON possiamo codificare:
- stringhe, numeri, boolean
- nulls (un tipo speciale a sé stante)
- tipi composti: oggetti e array.
O più precisamente, queste sono le versioni PHP delle cose che possono essere codificate in JSON.
Quando il JSON viene decodificato, si ottengono tipi PHP di base. Non c’è niente di speciale in loro. Non sono “oggetti JSON” o “array JSON”
Accesso alle proprietà degli oggetti
Si accede alle proprietà di uno di questi oggetti nello stesso modo in cui si farebbe per le proprietà pubbliche non statiche di qualsiasi altro oggetto, ad es. $object->property.
$json = '
{
"type": "donut",
"name": "Cake"
}';
$yummy = json_decode($json);
echo $yummy->type; //donut
Accesso agli elementi dell’array
Si accede agli elementi di uno di questi array nello stesso modo in cui si farebbe per qualsiasi altro array, ad es. $array[0].
$json = '
[
"Glazed",
"Chocolate with Sprinkles",
"Maple"
]';
$toppings = json_decode($json);
echo $toppings[1]; //Chocolate with Sprinkles
è possibile Iterare su di esso con foreach.
foreach ($toppings as $topping) {
echo $topping, "\\n";
}
O utilizzare una qualsiasi delle funzioni integrate sugli array
Accesso agli elementi nidificati
Le proprietà degli oggetti e gli elementi degli array potrebbero essere più oggetti e/o array: puoi semplicemente continuare ad accedere alle loro proprietà e ai membri come al solito, ad es. $object->array[0]->etc.
$json = '
{
"type": "donut",
"name": "Cake",
"toppings": [
{ "id": "5002", "type": "Glazed" },
{ "id": "5006", "type": "Chocolate with Sprinkles" },
{ "id": "5004", "type": "Maple" }
]
}';
$yummy = json_decode($json);
echo $yummy->toppings[2]->id; //5004
Ottenere array associativi anzichè oggetti
Passando true come secondo argomento a json_decode() invece di oggetti otterrai array associativi (array con stringhe come chiavi). Anche in questo caso accedi ai suoi elementi come al solito, ad es. $array[‘key’].
$json = '
{
"type": "donut",
"name": "Cake",
"toppings": [
{ "id": "5002", "type": "Glazed" },
{ "id": "5006", "type": "Chocolate with Sprinkles" },
{ "id": "5004", "type": "Maple" }
]
}';
$yummy = json_decode($json, true);
echo $yummy['toppings'][2]['type']; //Maple
Accesso agli elementi dell’array associativo
Quando si decodifica un oggetto JSON in un array PHP associativo, è possibile iterare sia le chiavi che i valori utilizzando la sintassi foreach (array_expression as $key => $value), ad esempio:
$json = '
{
"foo": "foo value",
"bar": "bar value",
"baz": "baz value"
}';
$assoc = json_decode($json, true);
foreach ($assoc as $key => $value) {
echo "The value of key '$key' is '$value'", PHP_EOL;
}
Verificare la strutturati dei dati
Guarda il JSON – dove vedi parentesi graffe {} avrai un oggetto, dove vedi parentesi quadre [] avrai un array.
Stampa i dati decodificati con print_r() o var_dump():
$json = '
{
"type": "donut",
"name": "Cake",
"toppings": [
{ "id": "5002", "type": "Glazed" },
{ "id": "5006", "type": "Chocolate with Sprinkles" },
{ "id": "5004", "type": "Maple" }
]
}';
$yummy = json_decode($json);
print_r($yummy);
e controlla l’output
stdClass Object
(
[type] => donut
[name] => Cake
[toppings] => Array
(
[0] => stdClass Object
(
[id] => 5002
[type] => Glazed
)
[1] => stdClass Object
(
[id] => 5006
[type] => Chocolate with Sprinkles
)
[2] => stdClass Object
(
[id] => 5004
[type] => Maple
)
)
)
Ti dirà dove hai gli oggetti, dove hai gli array, insieme ai nomi e ai valori dei loro membri.
Suddividi il problema in pezzi che sono più facili da leggere stampando solo una parte del JSON
print_r($yummy->toppings[0]);
stdClass Object
(
[id] => 5002
[type] => Glazed
)
Dai un’occhiata a questo pratico esploratore JSON interattivo.
json_decode() restituisce null
Questo accade perché:
- Il JSON è costituito interamente da questo, null.
- Il JSON non è valido: controlla il risultato di json_last_error_msg o inseriscilo in qualcosa come JSONLint.
- Il JSON contiene elementi nidificati a più di 512 livelli di profondità. Questa profondità massima predefinita può essere ignorata passando un intero come terzo argomento a json_decode().
Se devi modificare la profondità massima probabilmente stai risolvendo il problema sbagliato. Scopri perché stai ricevendo dati così profondamente nidificati (ad es. il servizio che stai interrogando che sta generando il JSON ha un bug) e fai in modo che non accada.
Carattere speciale nel nome della proprietà
A volte avrai un nome di proprietà dell’oggetto che contiene qualcosa come un trattino – o un segno @ che non può essere utilizzato in un identificatore letterale. Invece puoi usare una stringa letterale tra parentesi graffe per affrontarlo.
$json = '{"@attributes":{"answer":42}}';
$thing = json_decode($json);
echo $thing->{'@attributes'}->answer; //42
JSON nel JSON
È ridicolo, ma succede: c’è un JSON codificato come una stringa all’interno del tuo JSON. Decodifica, accedi alla stringa come al solito, decodificala e alla fine ottieni ciò di cui hai bisogno.
$json = '
{
"type": "donut",
"name": "Cake",
"toppings": "[{ \\"type\\": \\"Glazed\\" }, { \\"type\\": \\"Maple\\" }]"
}';
$yummy = json_decode($json);
$toppings = json_decode($yummy->toppings);
echo $toppings[0]->type; //Glazed
I dati non ci stanno in memoria
Se il tuo JSON è troppo grande per essere gestito da json_decode() in una volta, le cose iniziano a diventare complicate. Prova a guardare:
