(PHP 5 >= 5.2.0, PHP 7, PHP 8, PECL json >= 1.2.0)
json_encode — Retorna la representación JSON del valor dado
Devuelve un string con la representación JSON de
value.
La codificación se ve afectada por los flags suministrados
y además la codificación de los valores de tipo float dependen del valor de
serialize_precision.
value
El value a ser codificado. Puede ser de cualquier
tipo menos un resource.
Todos los datos de tipo string deben estar codificados con UTF-8.
Nota:
PHP implementa un superconjunto de JSON tal como se especifica en la » RFC 7159 original.
flags
Máscara de bits que compuesta por
JSON_FORCE_OBJECT,
JSON_HEX_QUOT,
JSON_HEX_TAG,
JSON_HEX_AMP,
JSON_HEX_APOS,
JSON_INVALID_UTF8_IGNORE,
JSON_INVALID_UTF8_SUBSTITUTE,
JSON_NUMERIC_CHECK,
JSON_PARTIAL_OUTPUT_ON_ERROR,
JSON_PRESERVE_ZERO_FRACTION,
JSON_PRETTY_PRINT,
JSON_UNESCAPED_LINE_TERMINATORS,
JSON_UNESCAPED_SLASHES,
JSON_UNESCAPED_UNICODE,
JSON_THROW_ON_ERROR.
El comportamiento de estas
constantes se describe en la página de
constantes de JSON.
depthEstablece la profundidad máxima. Debe ser mayor que cero.
| Versión | Descripción |
|---|---|
| 7.3.0 |
JSON_THROW_ON_ERROR
Se añadió a flags.
|
| 7.2.0 |
JSON_INVALID_UTF8_IGNORE, and
JSON_INVALID_UTF8_SUBSTITUTE
Se añadieron a flags.
|
| 7.1.0 |
JSON_UNESCAPED_LINE_TERMINATORS
Se añadió a flags.
|
| 7.1.0 | serialize_precision se utiliza en lugar de precision al codificar 'doubles'. |
Ejemplo #1 Un ejemplo de json_encode()
<?php
$arr = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5);
echo json_encode($arr);
?>El resultado del ejemplo sería:
{"a":1,"b":2,"c":3,"d":4,"e":5}
Ejemplo #2 Un ejemplo de json_encode() mostrando algunas de las opciones en acción
<?php
$a = array('<foo>',"'bar'",'"baz"','&blong&', "\xc3\xa9");
echo "Normal: ", json_encode($a), "\n";
echo "Tags: ", json_encode($a, JSON_HEX_TAG), "\n";
echo "Apos: ", json_encode($a, JSON_HEX_APOS), "\n";
echo "Quot: ", json_encode($a, JSON_HEX_QUOT), "\n";
echo "Amp: ", json_encode($a, JSON_HEX_AMP), "\n";
echo "Unicode: ", json_encode($a, JSON_UNESCAPED_UNICODE), "\n";
echo "All: ", json_encode($a, JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_HEX_AMP | JSON_UNESCAPED_UNICODE), "\n\n";
$b = array();
echo "Array vacío retornado como array: ", json_encode($b), "\n";
echo "Array vacío retornado como object: ", json_encode($b, JSON_FORCE_OBJECT), "\n\n";
$c = array(array(1,2,3));
echo "Array no asociativo retornado como array: ", json_encode($c), "\n";
echo "Array no asociativo retornado como objeto: ", json_encode($c, JSON_FORCE_OBJECT), "\n\n";
$d = array('foo' => 'bar', 'baz' => 'long');
echo "Array asociativo siempre es retornado como objeto: ", json_encode($d), "\n";
echo "Array asociativo siempre es retornado como objeto: ", json_encode($d, JSON_FORCE_OBJECT), "\n\n";
?>El resultado del ejemplo sería:
Normal: ["<foo>","'bar'","\"baz\"","&blong&","\u00e9"]
Tags: ["\u003Cfoo\u003E","'bar'","\"baz\"","&blong&","\u00e9"]
Apos: ["<foo>","\u0027bar\u0027","\"baz\"","&blong&","\u00e9"]
Quot: ["<foo>","'bar'","\u0022baz\u0022","&blong&","\u00e9"]
Amp: ["<foo>","'bar'","\"baz\"","\u0026blong\u0026","\u00e9"]
Unicode: ["<foo>","'bar'","\"baz\"","&blong&","é"]
All: ["\u003Cfoo\u003E","\u0027bar\u0027","\u0022baz\u0022","\u0026blong\u0026","é"]
Array vacío retornado como array: []
Array vacío retornado como object: {}
Array no asociativo retornado como array: [[1,2,3]]
Array no asociativo retornado como objeto: {"0":{"0":1,"1":2,"2":3}}
Array asociativo siempre es retornado como objeto: {"foo":"bar","baz":"long"}
Array asociativo siempre es retornado como objeto: {"foo":"bar","baz":"long"}
Ejemplo #3 Ejemplo de la opción JSON_NUMERIC_CHECK
<?php
echo "Los string que representan números automáticamente se convierten en números".PHP_EOL;
$numbers = array('+123123', '-123123', '1.2e3', '0.00001');
var_dump(
$numbers,
json_encode($numbers, JSON_NUMERIC_CHECK)
);
echo "String que contienen números formateados incorrectamente".PHP_EOL;
$strings = array('+a33123456789', 'a123');
var_dump(
$strings,
json_encode($strings, JSON_NUMERIC_CHECK)
);
?>El resultado del ejemplo sería:
Los string que representan números automáticamente se convierten en números
array(4) {
[0]=>
string(7) "+123123"
[1]=>
string(7) "-123123"
[2]=>
string(5) "1.2e3"
[3]=>
string(7) "0.00001"
}
string(28) "[123123,-123123,1200,1.0e-5]"
String que contienen números formateados incorrectamente
array(2) {
[0]=>
string(13) "+a33123456789"
[1]=>
string(4) "a123"
}
string(24) "["+a33123456789","a123"]"
Ejemplo #4 Ejemplo de array secuencial contra array no secuencial
<?php
echo "Array sencuencial".PHP_EOL;
$sequential = array("foo", "bar", "baz", "blong");
var_dump(
$sequential,
json_encode($sequential)
);
echo PHP_EOL."Array no secuencial".PHP_EOL;
$nonsequential = array(1=>"foo", 2=>"bar", 3=>"baz", 4=>"blong");
var_dump(
$nonsequential,
json_encode($nonsequential)
);
echo PHP_EOL."Array secuencial con una clave destruida".PHP_EOL;
unset($sequential[1]);
var_dump(
$sequential,
json_encode($sequential)
);
?>El resultado del ejemplo sería:
Array sencuencial
array(4) {
[0]=>
string(3) "foo"
[1]=>
string(3) "bar"
[2]=>
string(3) "baz"
[3]=>
string(5) "blong"
}
string(27) "["foo","bar","baz","blong"]"
Array no secuencial"
array(4) {
[1]=>
string(3) "foo"
[2]=>
string(3) "bar"
[3]=>
string(3) "baz"
[4]=>
string(5) "blong"
}
string(43) "{"1":"foo","2":"bar","3":"baz","4":"blong"}"
Array secuencial con una clave destruida
array(3) {
[0]=>
string(3) "foo"
[2]=>
string(3) "baz"
[3]=>
string(5) "blong"
}
string(33) "{"0":"foo","2":"baz","3":"blong"}"
Ejemplo #5 Ejemplo de la opción JSON_PRESERVE_ZERO_FRACTION
<?php
var_dump(json_encode(12.0, JSON_PRESERVE_ZERO_FRACTION));
var_dump(json_encode(12.0));
?>El resultado del ejemplo sería:
string(4) "12.0" string(2) "12"
Nota:
En el evento de un fallo a codificar, json_last_error() puede ser usado para determinar la naturaleza exacta del error.
Nota:
Cuando se codifica un array, si las claves no están en una secuencia numérica continua comenzando por 0, todas las claves son codificadas como cadenas, y explícitamente especificadas para cada pareja clave-valor.
Nota:
Al igual que el codificador JSON de referencia, json_encode() generará JSON que es un valor simple (esto es, ni un objeto ni un array) si de proporciona un string, integer, float o boolean como entrada de
value. Mientras que muchos decodificadores aceptarán estos valores como JSON válido, algunos no lo harán, ya que la especificación es ambigua en este aspecto.Para resumir, compruebe siempre que el decodificador de JSON puede manejar la salida que se genere desde json_encode().
Are you sure you want to use JSON_NUMERIC_CHECK, really really sure?
Just watch this usecase:
<?php
// International phone number
json_encode(array('phone_number' => '+33123456789'), JSON_NUMERIC_CHECK);
?>
And then you get this JSON:
{"phone_number":33123456789}
Maybe it makes sense for PHP (as is_numeric('+33123456789') returns true), but really, casting it as an int?!
So be careful when using JSON_NUMERIC_CHECK, it may mess up with your data!Notice that JSON_FORCE_OBJECT will convert all non-associative arrays to objects. This is not necessarily a good solution for empty arrays.
If you want to convert only empty arrays to objects, simply convert them to empty object before use json_encode function.
For example:
<?php
$foo=array(
'empty2object'=>(object)[],
'empty2array'=>[],
);
echo json_encode($foo); // {"empty2object":{},"empty2array":[]}
?>Attention when passing a plain array to json_encode and using JSON_FORCE_OBJECT. It figured out that the index-order of the resulting JSON-string depends on the system PHP is running on.
$a = array("a" , "b", "c");
echo json_encode($a, JSON_FORCE_OBJECT);
On Xampp (Windows) you get:
{"0":"a","1":"b","2":"c"}';
On a machine running debian I get:
{"2":"a","1":"b","0":"c"}';
Note that the key:value pairs are different!
Solution here was to use array_combine to create a ssociative array and then pass it to json_encode:
json_encode(array_combine(range(0, count($a) - 1), $a), JSON_FORCE_OBJECT);Be careful with floating values in some locales (e.g. russian) with comma (",") as decimal point. Code:
<?php
setlocale(LC_ALL, 'ru_RU.utf8');
$arr = array('element' => 12.34);
echo json_encode( $arr );
?>
Output will be:
--------------
{"element":12,34}
--------------
Which is NOT a valid JSON markup. You should convert floating point variable to strings or set locale to something like "LC_NUMERIC, 'en_US.utf8'" before using json_encode.I came across the "bug" where running json_encode() over a SimpleXML object was ignoring the CDATA. I ran across http://bugs.php.net/42001 and http://bugs.php.net/41976, and while I agree with the poster that the documentation should clarify gotchas like this, I was able to figure out how to workaround it.
You need to convert the SimpleXML object back into an XML string, then re-import it back into SimpleXML using the LIBXML_NOCDATA option. Once you do this, then you can use json_encode() and still get back the CDATA.
<?php
// Pretend we already have a complex SimpleXML object stored in $xml
$json = json_encode(new SimpleXMLElement($xml->asXML(), LIBXML_NOCDATA));
?>A note about json_encode automatically quoting numbers:
It appears that the json_encode function pays attention to the data type of the value. Let me explain what we came across:
We have found that when retrieving data from our database, there are occasions when numbers appear as strings to json_encode which results in double quotes around the values.
This can lead to problems within javascript functions expecting the values to be numeric.
This was discovered when were were retrieving fields from the database which contained serialized arrays. After unserializing them and sending them through the json_encode function the numeric values in the original array were now being treated as strings and showing up with double quotes around them.
The fix: Prior to encoding the array, send it to a function which checks for numeric types and casts accordingly. Encoding from then on worked as expected.The Problem:
---------------
When you filter an array in PHP using array_filter, the original keys are preserved. If you remove elements, you'll end up with gaps in the keys (non-consecutive). When encoded to JSON, this can lead to the list being interpreted as a JSON object instead of a JSON array, which might not be what your JavaScript code expects.
The Solution:
---------------
The array_values() function is essential in this scenario. It re-indexes the array with consecutive numerical keys (0, 1, 2, ...), ensuring that the JSON output is always a well-formed array.
Example:
----------
<?php
// Use Case: Filtering a list and ensuring consistent JSON array output
// Imagine you have a list of items and need to send a filtered version to a JavaScript frontend
// using JSON. You want to ensure the filtered list is always received as a JSON array,
// regardless of which items were removed.
// Sample data: A list of items
$items = [
"first",
"second",
"third",
"fourth",
"fifth"
];
// Items to remove from the list
$itemsToRemove = ["second", "fourth"];
// Filter the list, keeping original keys (which become non-consecutive)
$filteredItems = array_filter($items, function($item) use ($itemsToRemove) {
return !in_array($item, $itemsToRemove);
});
// Prepare data for JSON output
$output_arr = [
"list" => $filteredItems
];
// Output 1: JSON with non-consecutive keys (becomes an object)
echo "Output without array_values:\n";
echo json_encode($output_arr, JSON_PRETTY_PRINT) . "\n\n";
/* Output:
{
"list": {
"0": "first",
"2": "third",
"4": "fifth"
}
}
*/
// Reset keys to be consecutive using array_values
$output_arr['list'] = array_values($output_arr['list']);
// Output 2: JSON with consecutive keys (remains an array)
echo "Output with array_values:\n";
echo json_encode($output_arr, JSON_PRETTY_PRINT) . "\n";
/* Output:
{
"list": [
"first",
"third",
"fifth"
]
}
*/
?>Solution for UTF-8 Special Chars.
<?
$array = array('nome'=>'Paição','cidade'=>'São Paulo');
$array = array_map('htmlentities',$array);
//encode
$json = html_entity_decode(json_encode($array));
//Output: {"nome":"Paição","cidade":"São Paulo"}
echo $json;
?>Note that if you try to encode an array containing non-utf values, you'll get null values in the resulting JSON string. You can batch-encode all the elements of an array with the array_map function:
<?php
$encodedArray = array_map(utf8_encode, $rawArray);
?>If you need pretty-printed output, but want it indented by 2 spaces instead of 4:
$json_indented_by_4 = json_encode($output, JSON_UNESCAPED_SLASHES|JSON_PRETTY_PRINT);
$json_indented_by_2 = preg_replace('/^( +?)\\1(?=[^ ])/m', '$1', $json_indented_by_4);