PHP
JSON

Invoering

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

Opmerkingen

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

$array = ['Joel', 23, true, ['red', 'blue']];
echo json_encode($array);
echo json_encode($array, JSON_FORCE_OBJECT);

["Joel",23,true,["red","blue"]]
{"0":"Joel","1":23,"2":true,"3":{"0":"red","1":"blue"}}

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

{"tag":"<>","amp":"&","apos":"'","quot":"\""}
{"tag":"\u003C\u003E","amp":"\u0026","apos":"\u0027","quot":"\u0022"}

$array = ['23452', 23452];
echo json_encode($array);
echo json_encode($array, JSON_NUMERIC_CHECK);

["23452",23452]    
[23452,23452]

$array = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];
echo json_encode($array);
echo json_encode($array, JSON_PRETTY_PRINT);

{"a":1,"b":2,"c":3,"d":4}
{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4
}

$array = ['filename' => 'example.txt', 'path' => '/full/path/to/file/'];
echo json_encode($array);
echo json_encode($array, JSON_UNESCAPED_SLASHES);

{"filename":"example.txt","path":"\/full\/path\/to\/file"}
{"filename":"example.txt","path":"/full/path/to/file"}

$blues = ["english"=>"blue", "norwegian"=>"blå", "german"=>"blau"];
echo json_encode($blues);
echo json_encode($blues, JSON_UNESCAPED_UNICODE);

{"english":"blue","norwegian":"bl\u00e5","german":"blau"}
{"english":"blue","norwegian":"blå","german":"blau"}

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

{"file":null,"name":"foo.txt"}

$array = [5.0, 5.5];
echo json_encode($array);
echo json_encode($array, JSON_PRESERVE_ZERO_FRACTION);

[5,5.5]
[5.0,5.5]

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

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

JsonSerializable gebruiken in een object

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

public function jsonSerialize()

json_encode($User);

{"name":"John", "surname":"Doe", "username" : "TestJson"}

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

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