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 | .

PHP 5.x 5.3

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"}
PHP 5.x 5.3

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]
PHP 5.x 5.4

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"}
PHP 5.x 5.5

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"}
PHP 5.x 5.6

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]
PHP 7.x 7.1

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 is No 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

PHP 5.x 5.4

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);
    });


Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow