PHP
JSON

Introduktion

Syntax

• sträng json_encode (blandat $ värde [, int $ alternativ = 0 [, int $ djup = 512]])
• blandad json_decode (sträng $ json [, bool $ assoc = falsk [, int $ djup = 512 [, int $ optioner = 0]]])

parametrar

Anmärkningar

Avkodning av en JSON-sträng

json_decode() tar en JSON-kodad sträng som sin första parameter och analyserar den till en PHP-variabel.

Normalt json_decode() ett objekt av \ stdClass om det övre nivåobjektet i JSON-objektet är en ordlista eller en indexerad matris om JSON-objektet är en matris. Det kommer också att returnera skalvärden eller NULL för vissa skalvärden, till exempel enkla strängar, "true" , "false" och "null" . Det returnerar också NULL vid alla fel.

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

Använd var_dump() att se typerna och värdena för varje egenskap på objektet som vi avkodade ovan.

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

Output (notera variabeltyperna):

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

Obs! Variabeltyper i JSON omvandlades till sin PHP motsvarande.

För att returnera ett associerande array för JSON-objekt istället för att returnera ett objekt, skickas true som den andra parametern till 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);

Output (notera den arrayassociativa strukturen):

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

Den andra parametern ( $assoc ) har ingen effekt om variabeln som ska returneras inte är ett objekt.

Obs: Om du använder $assoc parametern förlorar du skillnaden mellan en tom matris och ett tomt objekt. Detta betyder att körning av json_encode() på din avkodade utgång igen, kommer att resultera i en annan JSON-struktur.

Om JSON-strängen har ett "djup" mer än 512 element ( 20 element i versioner äldre än 5.2.3, eller 128 i version 5.2.3 ) i rekursion, json_decode() funktionen json_decode() NULL . I version 5.3 eller senare kan denna gräns kontrolleras med den tredje parametern ( $depth ), som diskuteras nedan.

Enligt manualen:

PHP implementerar en superset av JSON som anges i originalen »RFC 4627 - den kommer också att koda och avkoda skalartyper och NULL. RFC 4627 stöder endast dessa värden när de kapslas in i en matris eller ett objekt. Även om denna superset överensstämmer med den utökade definitionen av "JSON text" i den nyare »RFC 7159 (som syftar till att ersätta RFC 4627) och » ECMA-404 , kan detta orsaka interoperabilitetsproblem med äldre JSON-parsers som strikt följer RFC 4627 när som kodar ett enda skalvärde.

Detta innebär att till exempel en enkel sträng kommer att anses vara ett giltigt JSON-objekt i PHP:

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

Produktion:

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

Men enkla strängar, inte i en matris eller ett objekt, ingår inte i RFC 4627- standarden. Som ett resultat kommer sådana online-checkar som JSLint , JSON Formatter & Validator (i RFC 4627-läge) att ge dig ett fel.

Det finns en tredje $depth djupparameter för rekursionsdjupet (standardvärdet är 512 ), vilket betyder mängden kapslade objekt i det ursprungliga objektet som ska avkodas.

Det finns en fjärde parameter för $options . Den accepterar för närvarande bara ett värde, JSON_BIGINT_AS_STRING . Standardbeteendet (som lämnar detta alternativ) är att kasta stora heltal till flottörer istället för strängar.

Ogiltiga icke-lägre varianter av sanna, falska och noll litteraler accepteras inte längre som giltiga inmatningar.

Så detta exempel:

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

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

Och efter:

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"

Liknande beteende förekommer för false och null .

Observera att json_decode() kommer att returnera NULL om strängen inte kan konverteras.

$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 

Det är inte säkert att bara lita på att returvärdet är NULL att upptäcka fel. Om till exempel JSON-strängen inte innehåller något annat än "null" kommer json_decode() att returnera null , även om inget fel inträffade.

Kodning av en JSON-sträng

Funktionen json_encode konverterar en PHP-array (eller sedan PHP 5.4, ett objekt som implementerar JsonSerializable gränssnittet) till en JSON-kodad sträng. Den returnerar en JSON-kodad sträng för framgång eller FALSE vid misslyckande.

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

Under kodningen konverteras PHP-datatypsträngen, heltal och boolean till deras JSON-ekvivalent. Associerande matriser kodas som JSON-objekt, och - när de anropas med standardargument - indexeras arrays som JSON-arrayer. (Om inte matrisknapparna inte är en kontinuerlig numerisk sekvens som börjar från 0, i vilket fall kommer matrisen att kodas som ett JSON-objekt.)

echo json_encode($array);

Produktion:

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

Argument

Sedan PHP 5.3 är det andra argumentet till json_encode en bitmask som kan vara ett eller flera av följande.

Som med alla bitmask kan de kombineras med den binära OR-operatören | .

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

Debugging JSON-fel

När json_encode eller json_decode misslyckas med att analysera den json_decode strängen kommer den att returnera false . PHP i sig kommer inte att ta upp några fel eller varningar när detta händer, onus är på användaren att använda json_last_error () och json_last_error_msg () -funktioner för att kontrollera om ett fel inträffade och agera i enlighet med det i din applikation (felsöka det, visa ett felmeddelande , etc.).

Följande exempel visar ett vanligt fel när du arbetar med JSON, ett fel vid avkodning / kodning av en JSON-sträng (till exempel på grund av att en dålig UTF-8-kodad sträng har passerat) .

// 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() returnerar ett mänskligt läsbart meddelande om det sista felet som inträffade när man försökte koda / avkoda en sträng.

• Denna funktion returnerar alltid en sträng , även om inget fel inträffade.
  Standardsträngen för icke-fel är No Error
• Det kommer att returnera false om något annat (okänt) fel inträffade
• Försiktigt när du använder detta i slingor, eftersom json_last_error_msg kommer att åsidosättas vid varje iteration.

Du bör bara använda den här funktionen för att få meddelandet för visning, inte att testa mot i kontrolluttalanden.

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

Den här funktionen finns inte före PHP 5.5. Här är en polyfillimplementering:

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() returnerar ett heltal mappat till en av de fördefinierade konstanterna som tillhandahålls av PHP.

Använda JsonSerializable i ett objekt

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 och det tillbaka svaret

Genom att lägga till en rubrik med innehållstyp som 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();

Rubriken är där så att din app kan upptäcka vilka data som returnerades och hur den ska hantera den.
Observera att: innehållshuvudet är bara information om typen av returnerade data.

Om du använder UTF-8 kan du använda:

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

Exempel jQuery:

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