PHP
JSON

Introducción

Sintaxis

• cadena json_encode (valor mezclado de $ [, int $ options = 0 [, int $ depth = 512]])
• json_decode mixto (string $ json [, bool $ assoc = false [, int $ depth = 512 [, int $ options = 0]]])

Parámetros

Observaciones

Decodificando una cadena JSON

La función json_decode() toma una cadena codificada en JSON como su primer parámetro y la analiza en una variable de PHP.

Normalmente, json_decode() devolverá un objeto de \ stdClass si el elemento de nivel superior en el objeto JSON es un diccionario o una matriz indexada si el objeto JSON es una matriz. También devolverá valores escalares o NULL para ciertos valores escalares, como cadenas simples, "true" , "false" y "null" . También devuelve NULL en cualquier error.

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

Use var_dump() para ver los tipos y valores de cada propiedad en el objeto que decodificamos arriba.

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

Salida (note los tipos de variables):

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

Nota: Los tipos de variables en JSON se convirtieron a su equivalente de PHP.

Para devolver una matriz asociativa para objetos JSON en lugar de devolver un objeto, pase true como segundo parámetro a 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);

Salida (note la estructura asociativa de la matriz):

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

El segundo parámetro ( $assoc ) no tiene efecto si la variable a devolver no es un objeto.

Nota: Si usa el parámetro $assoc , perderá la distinción entre una matriz vacía y un objeto vacío. Esto significa que ejecutar json_encode() en su salida descodificada de nuevo, resultará en una estructura JSON diferente.

Si la cadena JSON tiene una "profundidad" de más de 512 elementos ( 20 elementos en versiones anteriores a 5.2.3, o 128 en la versión 5.2.3 ) en recursión, la función json_decode() devuelve NULL . En las versiones 5.3 o posteriores, este límite se puede controlar mediante el tercer parámetro ( $depth ), como se explica a continuación.

Según el manual:

PHP implementa un superconjunto de JSON como se especifica en el »RFC 4627 original - también codificará y decodificará tipos escalares y NULL. RFC 4627 solo admite estos valores cuando están anidados dentro de una matriz o un objeto. Aunque este superconjunto es consistente con la definición ampliada de "texto JSON" en el »RFC 7159 más reciente (que apunta a reemplazar el RFC 4627) y » ECMA-404 , esto puede causar problemas de interoperabilidad con los analizadores JSON más antiguos que se adhieren estrictamente al RFC 4627 cuando codificando un solo valor escalar.

Esto significa que, por ejemplo, una cadena simple se considerará un objeto JSON válido en PHP:

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

Salida:

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

Pero las cadenas simples, que no están en una matriz u objeto, no forman parte del estándar RFC 4627 . Como resultado, los verificadores en línea como JSLint , JSON Formatter & Validator (en modo RFC 4627) le darán un error.

Hay un tercer parámetro $depth para la profundidad de la recursión (el valor predeterminado es 512 ), lo que significa la cantidad de objetos anidados dentro del objeto original a decodificar.

Hay un cuarto parámetro de $options . Actualmente solo acepta un valor, JSON_BIGINT_AS_STRING . El comportamiento predeterminado (que deja esta opción) es convertir enteros grandes en flotantes en lugar de cadenas.

Las variantes no escritas en minúsculas de los literales verdadero, falso y nulo ya no se aceptan como entrada válida.

Así que este ejemplo:

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

Antes de 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"

Y después:

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"

Similar comportamiento ocurre para false y null .

Tenga en cuenta que json_decode() devolverá NULL si la cadena no se puede convertir.

$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 

No es seguro confiar solo en que el valor de retorno sea NULL para detectar errores. Por ejemplo, si la cadena JSON no contiene nada más que "null" , json_decode() devolverá null , aunque no se haya producido ningún error.

Codificar una cadena JSON

La función json_encode convertirá una matriz PHP (o, desde PHP 5.4, un objeto que implementa la interfaz JsonSerializable ) en una cadena codificada en JSON. Devuelve una cadena codificada en JSON en caso de éxito o FALSE en caso de error.

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

Durante la codificación, los tipos de datos de PHP, cadena, entero y booleano se convierten a su equivalente JSON. Las matrices asociativas se codifican como objetos JSON y, cuando se llaman con argumentos predeterminados, las matrices indexadas se codifican como matrices JSON. (A menos que las claves de matriz no sean una secuencia numérica continua que comience desde 0, en cuyo caso la matriz se codificará como un objeto JSON).

echo json_encode($array);

Salida:

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

Argumentos

Desde PHP 5.3, el segundo argumento de json_encode es una máscara de bits que puede ser una o más de las siguientes.

Al igual que con cualquier máscara de bits, se pueden combinar con el operador binario OR | .

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

Depuración de errores JSON

Cuando json_encode o json_decode no puede analizar la cadena proporcionada, devolverá false . PHP en sí mismo no generará ningún error o advertencia cuando esto suceda, la responsabilidad del usuario es utilizar las funciones json_last_error () y json_last_error_msg () para verificar si ocurrió un error y actuar en consecuencia en su aplicación (depurarlo, mostrar un mensaje de error , etc.).

El siguiente ejemplo muestra un error común cuando se trabaja con JSON, un error al descodificar / codificar una cadena JSON (por ejemplo, al pasar una cadena codificada en UTF-8 incorrecta) .

// 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() devuelve un mensaje legible por humanos del último error que se produjo al intentar codificar / decodificar una cadena.

• Esta función siempre devolverá una cadena , incluso si no se produjo ningún error.
  La cadena predeterminada que no es de error es No Error
• Devolverá false si se produce algún otro error (desconocido)
• Tenga cuidado al usar esto en bucles, ya que json_last_error_msg se anulará en cada iteración.

Solo debe usar esta función para mostrar el mensaje, no para probar en las declaraciones de control.

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

Esta función no existe antes de PHP 5.5. Aquí hay una implementación de polyfill:

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() devuelve un entero asignado a una de las constantes predefinidas provistas por PHP.

Usando JsonSerializable en un objeto

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

Encabezado json y la respuesta devuelta

Añadiendo un encabezado con tipo de contenido como 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();

El encabezado está allí para que su aplicación pueda detectar qué datos se devolvieron y cómo debería manejarlos.
Tenga en cuenta que: el encabezado de contenido es solo información sobre el tipo de datos devueltos.

Si está utilizando UTF-8, puede usar:

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

Ejemplo jQuery:

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