PHP
JSON

Einführung

Syntax

• Zeichenfolge json_encode (gemischter $ value [, int $ options = 0 [, int $ depth = 512]])
• gemischter json_decode (String $ json [, bool $ assoc = false [, int $ tiefe = 512 [, int $ options = 0]]])

Parameter

Bemerkungen

Dekodierung einer JSON-Zeichenfolge

Die Funktion json_decode() nimmt einen JSON-codierten String als ersten Parameter und parst ihn in eine PHP-Variable.

Normalerweise gibt json_decode() ein Objekt von \ stdClass zurück, wenn das oberste Element des JSON-Objekts ein Wörterbuch oder ein indiziertes Array ist, wenn das JSON-Objekt ein Array ist. Es gibt auch Skalarwerte oder NULL für bestimmte Skalarwerte zurück, z. B. einfache Zeichenfolgen, "true" , "false" und "null" . Bei einem Fehler wird auch NULL .

// 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]);

Verwenden Sie var_dump() , um die Typen und Werte der einzelnen Eigenschaften des Objekts anzuzeigen, das wir oben dekodiert haben.

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

Ausgabe (beachten Sie die Variablentypen):

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"
   }
}

Hinweis: Die Variablentypen in JSON wurden in ihre PHP - Äquivalent umgewandelt.

Eine zurückzukehren assoziative Array für JSON Objekte anstelle ein Objekt zurückzugeben, übergeben true als der zweite Parameter auf 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);

Ausgabe (beachten Sie die Array-assoziative Struktur):

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

Der zweite Parameter ( $assoc ) hat keine Auswirkungen, wenn die zurückzugebende Variable kein Objekt ist.

Hinweis: Wenn Sie den $assoc Parameter verwenden, wird die Unterscheidung zwischen einem leeren Array und einem leeren Objekt $assoc . Das bedeutet, dass json_encode() auf Ihrer decodierten Ausgabe ausgeführt wird, führt dies zu einer anderen JSON-Struktur.

Wenn der JSON-String eine "Tiefe" von mehr als 512 Elementen aufweist ( 20 Elemente in älteren Versionen als 5.2.3 oder 128 in Version 5.2.3 ), wird die Funktion json_decode() NULL . In Versionen 5.3 oder höher kann dieser Grenzwert mit dem dritten Parameter ( $depth ) gesteuert werden (siehe unten).

Laut Handbuch:

PHP implementiert eine Obermenge von JSON wie in der ursprünglichen »RFC 4627- Spezifikation angegeben - es werden auch skalare Typen und NULL codiert und decodiert. RFC 4627 unterstützt diese Werte nur, wenn sie in einem Array oder einem Objekt verschachtelt sind. Obwohl diese Obermenge mit der erweiterten Definition von "JSON-Text" im neueren »RFC 7159 (die RFC 4627 ablösen soll) und » ECMA-404 übereinstimmt , kann dies Interoperabilitätsprobleme mit älteren JSON-Parsern verursachen, die sich strikt an RFC 4627 halten Kodierung eines einzelnen Skalarwerts.

Dies bedeutet, dass beispielsweise eine einfache Zeichenfolge als gültiges JSON-Objekt in PHP betrachtet wird:

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

Ausgabe:

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

Einfache Strings, die sich nicht in einem Array oder Objekt befinden, sind jedoch nicht Teil des RFC 4627- Standards. Als Ergebnis erhalten Online-Checker wie JSLint , JSON Formatter & Validator (im RFC 4627-Modus) einen Fehler.

Es gibt einen dritten $depth Parameter für die Rekursionstiefe (der Standardwert ist 512 ), d. H.

Es gibt einen vierten Parameter für $options . Es akzeptiert derzeit nur einen Wert, JSON_BIGINT_AS_STRING . Das Standardverhalten (das diese Option nicht zulässt) besteht darin, große Ganzzahlen anstelle von Zeichenfolgen in Floats umzuwandeln.

Ungültige nicht untergeordnete Varianten der True-, False- und NULL-Literale werden nicht mehr als gültige Eingabe akzeptiert.

Also dieses Beispiel:

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

Vor 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"

Und danach:

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"

Ähnliches Verhalten tritt für false und null .

Beachten Sie, dass json_decode() NULL json_decode() wenn der String nicht konvertiert werden kann.

$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 

Es ist nicht sicher, sich nur darauf zu verlassen, dass der Rückgabewert NULL , um Fehler zu erkennen. Wenn der JSON-String beispielsweise nur "null" , gibt json_decode() null , obwohl kein Fehler aufgetreten ist.

Kodierung einer JSON-Zeichenfolge

Die Funktion json_encode konvertiert ein PHP-Array (oder seit PHP 5.4 ein Objekt, das die JsonSerializable Schnittstelle implementiert) in eine JSON-codierte Zeichenfolge. Bei Erfolg wird eine JSON-codierte Zeichenfolge oder bei einem Fehler FALSE zurückgegeben.

$array = [
    'name' => 'Jeff',
    'age' => 20,
    'active' => true,
    'colors' => ['red', 'blue'],
    'values' => [0=>'foo', 3=>'bar'],
];

Während der Codierung werden die PHP-Datentypen string, integer und boolean in ihre JSON-Entsprechung konvertiert. Assoziative Arrays werden als JSON-Objekte codiert. Indem Sie mit Standardargumenten aufgerufen werden, werden indizierte Arrays als JSON-Arrays codiert. (Wenn die Array-Schlüssel keine fortlaufende numerische Sequenz sind, die bei 0 beginnt, wird das Array in diesem Fall als JSON-Objekt codiert.)

echo json_encode($array);

Ausgabe:

{"name":"Jeff","age":20,"active":true,"colors":["red","blue"],"values":{"0":"foo","3":"bar"}}

Argumente

Das zweite Argument für json_encode ist seit PHP 5.3 eine Bitmaske, die eine oder mehrere der folgenden sein kann.

Wie bei jeder Bitmaske können sie mit dem binären ODER-Operator | kombiniert werden .

$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 von JSON-Fehlern

Wenn json_encode oder json_decode die bereitgestellte json_decode nicht analysieren kann, wird false . PHP selbst erzeugt keine Fehler oder Warnungen, wenn dies geschieht. Der Benutzer muss die Funktionen json_last_error () und json_last_error_msg () verwenden, um zu prüfen, ob ein Fehler aufgetreten ist, und in der Anwendung entsprechend zu handeln (debuggen, Fehlermeldung anzeigen) , usw.).

Das folgende Beispiel zeigt einen häufigen Fehler bei der Arbeit mit JSON, einen Fehler beim Dekodieren / Kodieren einer JSON-Zeichenfolge (z. B. aufgrund einer fehlerhaften UTF-8-kodierten Zeichenfolge) .

// 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() gibt eine vom Menschen lesbare Nachricht des letzten Fehlers zurück, der beim Versuch aufgetreten ist, einen String zu codieren / decodieren.

• Diese Funktion gibt immer einen String zurück , auch wenn kein Fehler aufgetreten ist.
  Die Standard - Zeichenfolge ohne Fehler lautet No Error
• Es wird false wenn ein anderer (unbekannter) Fehler aufgetreten ist
• Vorsicht bei Verwendung in Schleifen, da json_last_error_msg bei jeder Iteration überschrieben wird.

Sie sollten diese Funktion nur verwenden, um die Nachricht zur Anzeige abzurufen, nicht um sie in Steueranweisungen zu testen.

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

Diese Funktion existiert nicht vor PHP 5.5. Hier ist eine Polyfill-Implementierung:

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() gibt eine Ganzzahl zurück , die einer der vordefinierten Konstanten von PHP zugeordnet ist.

JsonSerializable in einem Objekt verwenden

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 und die zurückgegebene Antwort

Durch Hinzufügen eines Headers mit dem Inhaltstyp 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();

Der Header ist vorhanden, damit Ihre App feststellen kann, welche Daten zurückgegeben wurden und wie sie damit umgehen sollte.
Beachten Sie Folgendes: Der Inhaltsheader enthält lediglich Informationen zum Typ der zurückgegebenen Daten.

Wenn Sie UTF-8 verwenden, können Sie Folgendes verwenden:

header("Content-Type: application/json;charset=utf-8");

Beispiel jQuery:

$.ajax({
        url:'url_your_page_php_that_return_json'        
    }).done(function(data){
        console.table('json ',data);
        console.log('Menu1 : ', data.menu1);
    });