Zoeken…
Invoering
JSON ( JavaScript Object Notation ) is een platform- en taalonafhankelijke manier om objecten in gewone tekst te serialiseren. Omdat het vaak op internet wordt gebruikt en PHP ook, is er een basisextensie voor het werken met JSON in PHP.
Syntaxis
- string json_encode (gemengde $ waarde [, int $ options = 0 [, int $ depth = 512]])
- gemengde json_decode (string $ json [, bool $ assoc = false [, int $ depth = 512 [, int $ options = 0]]])
parameters
Parameter | Details |
---|---|
json_encode | - |
waarde | De waarde die wordt gecodeerd. Kan elk type zijn, behalve een bron. Alle stringgegevens moeten UTF-8-gecodeerd zijn. |
opties | Bitmasker, bestaande uit JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT, JSON_PRESERVE_ZEROSON_OPLEER Het gedrag van deze constanten wordt beschreven op de JSON-constantenpagina . |
diepte | Stel de maximale diepte in. Moet groter zijn dan nul. |
json_decode | - |
json | De json-string wordt gedecodeerd. Deze functie werkt alleen met UTF-8-gecodeerde tekenreeksen. |
Assoc | Moet de functie associatieve array retourneren in plaats van objecten. |
opties | Bitmasker van JSON-decodeeropties. Momenteel wordt alleen JSON_BIGINT_AS_STRING ondersteund (standaard worden grote gehele getallen als drijvers gecast) |
Opmerkingen
- json_decode afhandeling van ongeldige JSON is erg schilferig, en het is erg moeilijk om betrouwbaar te bepalen of de decodering is geslaagd, json_decode retourneert null voor ongeldige invoer, hoewel null ook een perfect geldig object is voor JSON om naar te decoderen. Om dergelijke problemen te voorkomen, moet u altijd json_last_error bellen wanneer u het gebruikt.
Decodering van een JSON-string
De functie json_decode()
neemt een JSON-gecodeerde string als zijn eerste parameter en parseert deze in een PHP-variabele.
Normaal gesproken retourneert json_decode()
een object van \ stdClass als het item op het hoogste niveau in het JSON-object een woordenboek of een geïndexeerde array is als het JSON-object een array is. Het retourneert ook scalaire waarden of NULL
voor bepaalde scalaire waarden, zoals eenvoudige tekenreeksen, "true"
, "false"
en "null"
. Het retourneert ook NULL
bij elke fout.
// 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]);
Gebruik var_dump()
om de typen en waarden van elke eigenschap te bekijken van het object dat we hierboven hebben gedecodeerd.
// Dump our above $object to view how it was decoded
var_dump($object);
Uitgang (let op de variabeletypen):
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"
}
}
Opmerking: De variabele types in JSON werden omgezet in hun PHP equivalent.
Als u een associatieve array voor JSON-objecten wilt retourneren in plaats van een object te retourneren, geeft u true
als de tweede parameter door aan 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);
Uitvoer (let op de associatieve structuur van de array):
array(4) {
["name"] => string(4) "Jeff"
["age"] => int(20)
["active"] => bool(true)
["colors"] =>
array(2) {
[0] => string(3) "red"
[1] => string(4) "blue"
}
}
De tweede parameter ( $assoc
) heeft geen effect als de te retourneren variabele geen object is.
Opmerking: als u de parameter $assoc
, verliest u het onderscheid tussen een lege array en een leeg object. Dit betekent dat het opnieuw uitvoeren van json_encode()
op uw gedecodeerde uitvoer een andere JSON-structuur tot gevolg heeft.
Als de JSON-tekenreeks een "diepte" van meer dan 512 elementen ( 20 elementen in versies ouder dan 5.2.3 of 128 in versie 5.2.3 ) in recursie heeft, retourneert de functie json_decode()
NULL
. In versies 5.3 of hoger kan deze limiet worden geregeld met behulp van de derde parameter ( $depth
), zoals hieronder wordt besproken.
Volgens de handleiding:
PHP implementeert een superset van JSON zoals gespecificeerd in de originele »RFC 4627 - het zal ook scalaire types en NULL coderen en decoderen. RFC 4627 ondersteunt deze waarden alleen wanneer ze zijn genest in een array of een object. Hoewel deze superset consistent is met de uitgebreide definitie van "JSON-tekst" in de nieuwere »RFC 7159 (die beoogt RFC 4627 te vervangen) en » ECMA-404 , kan dit interoperabiliteitsproblemen veroorzaken met oudere JSON-parsers die zich strikt houden aan RFC 4627 wanneer codering van een enkele scalaire waarde.
Dit betekent dat bijvoorbeeld een eenvoudige string als een geldig JSON-object in PHP wordt beschouwd:
$json = json_decode('"some string"', true);
var_dump($json, json_last_error_msg());
Output:
string(11) "some string"
string(8) "No error"
Maar eenvoudige tekenreeksen, niet in een array of object, maken geen deel uit van de RFC 4627- standaard. Als gevolg hiervan geven online checkers als JSLint , JSON Formatter & Validator (in RFC 4627-modus) een foutmelding.
Er is een derde parameter $depth
voor de diepte van de recursie (de standaardwaarde is 512
), wat betekent dat het aantal geneste objecten binnen het oorspronkelijke te decoderen object ligt.
Er is een vierde parameter voor $options
. Het accepteert momenteel slechts één waarde, JSON_BIGINT_AS_STRING
. Het standaardgedrag (waardoor deze optie wordt weggelaten) is om grote gehele getallen naar floats te werpen in plaats van tekenreeksen.
Ongeldige niet-kleine varianten van de juiste, valse en nulletter worden niet langer geaccepteerd als geldige invoer.
Dus dit voorbeeld:
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());
Voor 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"
En daarna:
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"
Soortgelijke gedrag treedt op voor false
en null
.
Merk op dat json_decode()
NULL
retourneert als de tekenreeks niet kan worden geconverteerd.
$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
Het is niet veilig om alleen te vertrouwen op de retourwaarde NULL
om fouten te detecteren. Als de JSON-tekenreeks bijvoorbeeld alleen "null"
, retourneert json_decode()
null
, ook al is er geen fout opgetreden.
Codering van een JSON-string
De functie json_encode
converteert een PHP-array (of, sinds PHP 5.4, een object dat de JsonSerializable
interface implementeert) naar een JSON-gecodeerde string. Het retourneert een JSON-gecodeerde string bij succes of FALSE bij mislukking.
$array = [
'name' => 'Jeff',
'age' => 20,
'active' => true,
'colors' => ['red', 'blue'],
'values' => [0=>'foo', 3=>'bar'],
];
Tijdens het coderen worden de PHP-gegevenstypes string, integer en boolean geconverteerd naar hun JSON-equivalent. Associatieve arrays worden gecodeerd als JSON-objecten, en - wanneer opgeroepen met standaardargumenten - worden geïndexeerde arrays gecodeerd als JSON-arrays. (Tenzij de array-toetsen geen doorlopende numerieke reeks zijn die begint bij 0, in welk geval de array wordt gecodeerd als een JSON-object.)
echo json_encode($array);
Output:
{"name":"Jeff","age":20,"active":true,"colors":["red","blue"],"values":{"0":"foo","3":"bar"}}
argumenten
Sinds PHP 5.3 is het tweede argument voor json_encode
een bitmasker dat een of meer van de volgende kan zijn.
Zoals met elk bitmasker, kunnen ze worden gecombineerd met de binaire OR-operator |
.
JSON_FORCE_OBJECT
Dwingt de creatie van een object in plaats van een array
$array = ['Joel', 23, true, ['red', 'blue']];
echo json_encode($array);
echo json_encode($array, JSON_FORCE_OBJECT);
Output:
["Joel",23,true,["red","blue"]]
{"0":"Joel","1":23,"2":true,"3":{"0":"red","1":"blue"}}
JSON_HEX_TAG
, JSON_HEX_AMP
, JSON_HEX_APOS
, JSON_HEX_QUOT
Zorgt voor de volgende conversies tijdens het coderen:
Constante | Invoer | uitgang |
---|---|---|
JSON_HEX_TAG | < | \u003C |
JSON_HEX_TAG | > | \u003E |
JSON_HEX_AMP | & | \u0026 |
JSON_HEX_APOS | ' | \u0027 |
JSON_HEX_QUOT | " | \u0022 |
$array = ["tag"=>"<>", "amp"=>"&", "apos"=>"'", "quot"=>"\""];
echo json_encode($array);
echo json_encode($array, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT);
Output:
{"tag":"<>","amp":"&","apos":"'","quot":"\""}
{"tag":"\u003C\u003E","amp":"\u0026","apos":"\u0027","quot":"\u0022"}
JSON_NUMERIC_CHECK
Zorgt ervoor dat numerieke tekenreeksen worden geconverteerd naar gehele getallen.
$array = ['23452', 23452];
echo json_encode($array);
echo json_encode($array, JSON_NUMERIC_CHECK);
Output:
["23452",23452]
[23452,23452]
JSON_PRETTY_PRINT
Maakt de JSON gemakkelijk leesbaar
$array = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];
echo json_encode($array);
echo json_encode($array, JSON_PRETTY_PRINT);
Output:
{"a":1,"b":2,"c":3,"d":4}
{
"a": 1,
"b": 2,
"c": 3,
"d": 4
}
JSON_UNESCAPED_SLASHES
Bevat schuine strepen /
voorwaartse schuine strepen in de uitvoer
$array = ['filename' => 'example.txt', 'path' => '/full/path/to/file/'];
echo json_encode($array);
echo json_encode($array, JSON_UNESCAPED_SLASHES);
Output:
{"filename":"example.txt","path":"\/full\/path\/to\/file"}
{"filename":"example.txt","path":"/full/path/to/file"}
JSON_UNESCAPED_UNICODE
Neemt UTF8-gecodeerde tekens op in de uitvoer in plaats van \u
gecodeerde tekenreeksen
$blues = ["english"=>"blue", "norwegian"=>"blå", "german"=>"blau"];
echo json_encode($blues);
echo json_encode($blues, JSON_UNESCAPED_UNICODE);
Output:
{"english":"blue","norwegian":"bl\u00e5","german":"blau"}
{"english":"blue","norwegian":"blå","german":"blau"}
JSON_PARTIAL_OUTPUT_ON_ERROR
Hiermee kan de codering worden voortgezet als bepaalde niet-codeerbare waarden worden aangetroffen.
$fp = fopen("foo.txt", "r");
$array = ["file"=>$fp, "name"=>"foo.txt"];
echo json_encode($array); // no output
echo json_encode($array, JSON_PARTIAL_OUTPUT_ON_ERROR);
Output:
{"file":null,"name":"foo.txt"}
JSON_PRESERVE_ZERO_FRACTION
Zorgt ervoor dat drijvers altijd als drijvers worden gecodeerd.
$array = [5.0, 5.5];
echo json_encode($array);
echo json_encode($array, JSON_PRESERVE_ZERO_FRACTION);
Output:
[5,5.5]
[5.0,5.5]
JSON_UNESCAPED_LINE_TERMINATORS
Bij gebruik met JSON_UNESCAPED_UNICODE
, keert terug naar het gedrag van oudere PHP-versies en ontsnapt niet aan de tekens U + 2028 LINE SEPARATOR en U + 2029 PARAGRAPH SEPARATOR. Hoewel geldig in JSON, zijn deze tekens niet geldig in JavaScript, dus het standaardgedrag van JSON_UNESCAPED_UNICODE
is gewijzigd in versie 7.1.
$array = ["line"=>"\xe2\x80\xa8", "paragraph"=>"\xe2\x80\xa9"];
echo json_encode($array, JSON_UNESCAPED_UNICODE);
echo json_encode($array, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_LINE_TERMINATORS);
Output:
{"line":"\u2028","paragraph":"\u2029"}
{"line":"
","paragraph":"
"}
Debuggen van JSON-fouten
Wanneer json_encode
of json_decode
json_encode
json_decode
niet kan parseren, retourneert deze false
. PHP zelf zal geen fouten of waarschuwingen veroorzaken wanneer dit gebeurt, het is aan de gebruiker om de functies json_last_error () en json_last_error_msg () te gebruiken om te controleren of er een fout is opgetreden en dienovereenkomstig in uw toepassing te handelen (fouten opsporen , een foutmelding weergeven , enz.).
Het volgende voorbeeld toont een veelvoorkomende fout bij het werken met JSON, een fout bij het decoderen / coderen van een JSON-string (bijvoorbeeld vanwege het doorgeven van een slechte UTF-8-gecodeerde string) .
// An incorrectly formed JSON string
$jsonString = json_encode("{'Bad JSON':\xB1\x31}");
if (json_last_error() != JSON_ERROR_NONE) {
printf("JSON Error: %s", json_last_error_msg());
}
#> JSON Error: Malformed UTF-8 characters, possibly incorrectly encoded
json_last_error_msg
json_last_error_msg()
retourneert een voor mensen leesbaar bericht van de laatste fout die is opgetreden bij het coderen / decoderen van een tekenreeks.
- Deze functie retourneert altijd een tekenreeks , zelfs als er geen fout is opgetreden.
De standaardreeks zonder fouten isNo Error
- Het zal
false
retourneren als er een andere (onbekende) fout is opgetreden - Wees voorzichtig wanneer u dit in lussen gebruikt, omdat json_last_error_msg bij elke iteratie wordt opgeheven.
Gebruik deze functie alleen om het bericht te krijgen voor weergave, niet om te testen in controleverklaringen.
// Don't do this:
if (json_last_error_msg()){} // always true (it's a string)
if (json_last_error_msg() != "No Error"){} // Bad practice
// Do this: (test the integer against one of the pre-defined constants)
if (json_last_error() != JSON_ERROR_NONE) {
// Use json_last_error_msg to display the message only, (not test against it)
printf("JSON Error: %s", json_last_error_msg());
}
Deze functie bestaat niet vóór PHP 5.5. Hier is een polyfill-implementatie:
if (!function_exists('json_last_error_msg')) {
function json_last_error_msg() {
static $ERRORS = array(
JSON_ERROR_NONE => 'No error',
JSON_ERROR_DEPTH => 'Maximum stack depth exceeded',
JSON_ERROR_STATE_MISMATCH => 'State mismatch (invalid or malformed JSON)',
JSON_ERROR_CTRL_CHAR => 'Control character error, possibly incorrectly encoded',
JSON_ERROR_SYNTAX => 'Syntax error',
JSON_ERROR_UTF8 => 'Malformed UTF-8 characters, possibly incorrectly encoded'
);
$error = json_last_error();
return isset($ERRORS[$error]) ? $ERRORS[$error] : 'Unknown error';
}
}
json_last_error
json_last_error()
retourneert een geheel getal toegewezen aan een van de vooraf gedefinieerde constanten geleverd door PHP.
Constante | Betekenis |
---|---|
JSON_ERROR_NONE | Er is geen fout opgetreden |
JSON_ERROR_DEPTH | De maximale stapeldiepte is overschreden |
JSON_ERROR_STATE_MISMATCH | Ongeldige of misvormde JSON |
JSON_ERROR_CTRL_CHAR | Besturingstekenfout, mogelijk onjuist gecodeerd |
JSON_ERROR_SYNTAX | Syntaxisfout (sinds PHP 5.3.3) |
JSON_ERROR_UTF8 | Misvormde UTF-8-tekens, mogelijk onjuist gecodeerd (sinds PHP 5.5.0) |
JSON_ERROR_RECURSION | Een of meer recursieve referenties in de te coderen waarde |
JSON_ERROR_INF_OR_NAN | Een of meer NAN- of INF-waarden in de te coderen waarde |
JSON_ERROR_UNSUPPORTED_TYPE | Er is een waarde opgegeven van een type dat niet kan worden gecodeerd |
JsonSerializable gebruiken in een object
Wanneer u REST API's bouwt, moet u mogelijk de informatie verkleinen van een object dat aan de clienttoepassing moet worden doorgegeven. Voor dit doel illustreert dit voorbeeld hoe de JsonSerialiazble
interface te gebruiken.
In dit voorbeeld breidt de klasse User
eigenlijk een DB-modelobject van een hypotetische ORM uit.
class User extends Model implements JsonSerializable {
public $id;
public $name;
public $surname;
public $username;
public $password;
public $email;
public $date_created;
public $date_edit;
public $role;
public $status;
public function jsonSerialize() {
return [
'name' => $this->name,
'surname' => $this->surname,
'username' => $this->username
];
}
}
Voeg de JsonSerializable
implementatie toe aan de klasse door de methode jsonSerialize()
te bieden.
public function jsonSerialize()
Nu in uw toepassingscontroller of script, wanneer u het object Gebruiker json_encode()
aan json_encode()
, krijgt u de geretourneerde json-gecodeerde array van de methode jsonSerialize()
plaats van het gehele object.
json_encode($User);
Zal terugkomen:
{"name":"John", "surname":"Doe", "username" : "TestJson"}
eigenschappen waarden voorbeeld.
Dit vermindert zowel de hoeveelheid gegevens die worden geretourneerd vanuit een RESTful-eindpunt en maakt het mogelijk om objecteigenschappen uit te sluiten van een json-weergave.
Privé- en beschermde eigenschappen gebruiken met json_encode()
Om te voorkomen dat JsonSerializable wordt gebruikt, is het ook mogelijk om privé- of beveiligde eigenschappen te gebruiken om klasse-informatie te verbergen voor de uitvoer van json_encode()
. De klasse hoeft dan geen \ JsonSerializable te implementeren.
De functie json_encode () codeert alleen openbare eigenschappen van een klasse in JSON.
<?php
class User {
// private properties only within this class
private $id;
private $date_created;
private $date_edit;
// properties used in extended classes
protected $password;
protected $email;
protected $role;
protected $status;
// share these properties with the end user
public $name;
public $surname;
public $username;
// jsonSerialize() not needed here
}
$theUser = new User();
var_dump(json_encode($theUser));
Output:
string(44) "{"name":null,"surname":null,"username":null}"
Header json en het geretourneerde antwoord
Door een kop met inhoudstype toe te voegen als JSON:
<?php
$result = array('menu1' => 'home', 'menu2' => 'code php', 'menu3' => 'about');
//return the json response :
header('Content-Type: application/json'); // <-- header declaration
echo json_encode($result, true); // <--- encode
exit();
De koptekst is aanwezig, zodat uw app kan detecteren welke gegevens zijn geretourneerd en hoe hiermee moet worden omgegaan.
Merk op dat: de inhoudskop alleen informatie is over het type geretourneerde gegevens.
Als u UTF-8 gebruikt, kunt u het volgende gebruiken:
header("Content-Type: application/json;charset=utf-8");
Voorbeeld jQuery:
$.ajax({
url:'url_your_page_php_that_return_json'
}).done(function(data){
console.table('json ',data);
console.log('Menu1 : ', data.menu1);
});