(PHP 5 >= 5.2.0, PHP 7, PHP 8, PECL json >= 1.2.0)
json_encode — Liefert die JSON-Darstellung eines Wertes
Gibt eine Zeichenkette zurück, die die JSON-Darstellung des übergebenen
value beinhaltet. Wenn der Parameter ein Array
oder Objekt ist, wird er rekursiv serialisiert.
Wenn ein Wert, der serialisiert werden soll, ein Objekt ist, dann werden standardmäßig nur die öffentlich sichtbaren Eigenschaften einbezogen. Alternativ dazu kann eine Klasse JsonSerializable implementieren, um zu steuern, wie ihre Werte zu JSON serialisiert werden.
Die Kodierung wird von den übergebenen flags
beeinflusst und zusätzlich hängt die Kodierung von Float-Werten vom Wert
von serialize_precision ab.
value
Der zu kodierende value. Kann von jedem Typ
außer Ressource sein.
Alle Zeichenketten müssen in UTF-8 kodiert sein.
Hinweis:
PHP implementiert eine Obermenge von JSON wie im Original » RFC 7159 beschrieben.
flags
Eine Bitmaske bestehend aus
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. Das Verhalten dieser
Konstanten ist auf der Seite über die
JSON-Konstanten beschrieben.
depthSetzt die maximale Verschachtelungstiefe. Muss größer als Null sein.
Gibt einen JSON-kodierten String zurück. Bei einem Fehler wird false zurückgegeben.
| Version | Beschreibung |
|---|---|
| 7.3.0 |
Die flags-Konstante
JSON_THROW_ON_ERROR wurde hinzugefügt.
|
| 7.2.0 |
Die flags-Konstanten
JSON_INVALID_UTF8_IGNORE und
JSON_INVALID_UTF8_SUBSTITUTE wurden hinzugefügt.
|
| 7.1.0 |
Die flags-Konstante
JSON_UNESCAPED_LINE_TERMINATORS wurde
hinzugefügt.
|
| 7.1.0 | serialize_precision wird nun anstatt precision verwendet, wenn Werte vom Typ float (Gleitkommazahlen) kodiert werden. |
Beispiel #1 Ein json_encode()-Beispiel
<?php
$arr = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5);
echo json_encode($arr);
?>Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
{"a":1,"b":2,"c":3,"d":4,"e":5}
Beispiel #2 Ein json_encode()-Beispiel, das den Einsatz einiger Optionen zeigt
<?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 "Ausgabe eines leeren Arrays als Array: ", json_encode($b), "\n";
echo "Ausgabe eines leeren Arrays als Objekt: ", json_encode($b, JSON_FORCE_OBJECT), "\n\n";
$c = array(array(1,2,3));
echo "Ausgabe eines nichtassoziativen Arrays als Array: ", json_encode($c), "\n";
echo "Ausgabe eines nichtassoziativen Arrays als Objekt: ", json_encode($c, JSON_FORCE_OBJECT), "\n\n";
$d = array('foo' => 'bar', 'baz' => 'long');
echo "Assoziative Arrays werden immer als Objekt ausgegeben: ", json_encode($d), "\n";
echo "Assoziative Arrays werden immer als Objekt ausgegeben: ", json_encode($d, JSON_FORCE_OBJECT), "\n\n";
?>Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
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","é"]
Ausgabe eines leeren Arrays als Array: []
Ausgabe eines leeren Arrays als Objekt: {}
Ausgabe eines nichtassoziativen Arrays als Array: [[1,2,3]]
Ausgabe eines nichtassoziativen Arrays als Objekt: {"0":{"0":1,"1":2,"2":3}}
Assoziative Arrays werden immer als Objekt ausgegeben: {"foo":"bar","baz":"long"}
Assoziative Arrays werden immer als Objekt ausgegeben: {"foo":"bar","baz":"long"}
Beispiel #3 JSON_NUMERIC_CHECK-Option-Beispiel
<?php
echo "Zeichenketten, die Zahlen darstellen, werden automatisch in Zahlen umgewandelt".PHP_EOL;
$numbers = array('+123123', '-123123', '1.2e3', '0.00001');
var_dump(
$numbers,
json_encode($numbers, JSON_NUMERIC_CHECK)
);
echo "Zeichenketten, die unsachgemäß formatierte Zahlen enthalten".PHP_EOL;
$strings = array('+a33123456789', 'a123');
var_dump(
$strings,
json_encode($strings, JSON_NUMERIC_CHECK)
);
?>Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:
Zeichenketten, die Zahlen darstellen, werden automatisch in Zahlen umgewandelt
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]"
Zeichenketten, die unsachgemäß formatierte Zahlen enthalten
array(2) {
[0]=>
string(13) "+a33123456789"
[1]=>
string(4) "a123"
}
string(24) "["+a33123456789","a123"]"
Beispiel #4 Beispiel für sequentielle und nicht sequentielle Arrays
<?php
echo "Sequentielles Array".PHP_EOL;
$sequential = array("foo", "bar", "baz", "blong");
var_dump(
$sequential,
json_encode($sequential)
);
echo PHP_EOL."Nicht-sequentielles Array".PHP_EOL;
$nonsequential = array(1=>"foo", 2=>"bar", 3=>"baz", 4=>"blong");
var_dump(
$nonsequential,
json_encode($nonsequential)
);
echo PHP_EOL."Sequentielles Array mit einem entfernten Schlüssel".PHP_EOL;
unset($sequential[1]);
var_dump(
$sequential,
json_encode($sequential)
);
?>Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Sequentielles Array
array(4) {
[0]=>
string(3) "foo"
[1]=>
string(3) "bar"
[2]=>
string(3) "baz"
[3]=>
string(5) "blong"
}
string(27) "["foo","bar","baz","blong"]"
Nicht-sequentielles Array
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"}"
Sequentielles Array mit einem entfernten Schlüssel
array(3) {
[0]=>
string(3) "foo"
[2]=>
string(3) "baz"
[3]=>
string(5) "blong"
}
string(33) "{"0":"foo","2":"baz","3":"blong"}"
Beispiel #5 JSON_PRESERVE_ZERO_FRACTION-Option-Beispiel
<?php
var_dump(json_encode(12.0, JSON_PRESERVE_ZERO_FRACTION));
var_dump(json_encode(12.0));
?>Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
string(4) "12.0" string(2) "12"
Hinweis:
Falls ein Fehler beim kodieren auftritt, kann json_last_error() verwendet werden, um die genaue Ursache des Fehlers festzustellen.
Hinweis:
Wenn ein Array kodiert wird und die Schlüssel keine kontinuierliche numerische Folge, beginnend bei 0, sind, werden alle Schlüssel als Zeichenketten kodiert und explizit für jedes Schlüssel-Wert-Paar angegeben.
Hinweis:
Wie der Referenz JSON-Encoder gibt auch json_encode() einen einfachen Wert (also weder ein Objekt noch ein Array) aus, wenn ein String, Integer, Float oder Boolean als Eingabe für
valueübergeben wird. Während die meisten Decoder diese Werte als gültiges JSON akzeptieren, könnte es einige geben die dies ablehnen, da die Spezifikationen in diesem Punkt mehrdeutig sind.Um es zusammenzufassen: Prüfen Sie immer, ob ihr JSON-Decoder die Ausgabe, die Sie mittels json_encode() erzeugen, verarbeiten kann.
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":[]}
?>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));
?>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);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);JSON Encode Huge Data with minimum Memory footprint.
<?php
/**
* Creates JSON
*
* This class is built to avoid creation of large array objects
* (which leads to memory limit issues for larger data set)
* which are then converted to JSON. This class gives access to
* create JSON in parts for what ever smallest part of data
* we have of the large data set which are yet to be fetched.
*/
class JsonEncode
{
/**
* Array of JsonEncodeObject objects
*
* @var array
*/
private $objects = [];
/**
* Current JsonEncodeObject object
*
* @var object
*/
private $currentObject = null;
/**
* JsonEncode constructor
*/
public function __construct()
{
}
/**
* Escape the json string key or value
*
* @param string $str json key or value string.
* @return string
*/
private function escape($str)
{
if (is_null($str)) return 'null';
$escapers = array("\\", "/", "\"", "\n", "\r", "\t", "\x08", "\x0c");
$replacements = array("\\\\", "\\/", "\\\"", "\\n", "\\r", "\\t", "\\f", "\\b");
$str = str_replace($escapers, $replacements, $str);
return '"' . $str . '"';
}
/**
* Encodes both simple and associative array to json
*
* @param $arr string value escaped and array value json_encode function is applied.
* @return void
*/
public function encode($arr)
{
if ($this->currentObject) {
echo $this->currentObject->comma;
}
if (is_array($arr)) {
echo json_encode($arr);
} else {
echo $this->escape($arr);
}
if ($this->currentObject) {
$this->currentObject->comma = ',';
}
}
/**
* Add simple array/value as in the json format.
*
* @param $value data type is string/array. This is used to add value/array in the current Array.
* @return void
*/
public function addValue($value)
{
if ($this->currentObject->mode !== 'Array') {
throw new Exception('Mode should be Array');
}
$this->encode($value);
}
/**
* Add simple array/value as in the json format.
*
* @param string $key key of associative array
* @param $value data type is string/array. This is used to add value/array in the current Array.
* @return void
*/
public function addKeyValue($key, $value)
{
if ($this->currentObject->mode !== 'Assoc') {
throw new Exception('Mode should be Assoc');
}
echo $this->currentObject->comma;
echo $this->escape($key) . ':';
$this->currentObject->comma = '';
$this->encode($value);
}
/**
* Start simple array
*
* @param string $key Used while creating simple array inside an associative array and $key is the key.
* @return void
*/
public function startArray($key = null)
{
if ($this->currentObject) {
echo $this->currentObject->comma;
array_push($this->objects, $this->currentObject);
}
$this->currentObject = new JsonEncodeObject('Array');
if (!is_null($key)) {
echo $this->escape($key) . ':';
}
echo '[';
}
/**
* End simple array
*
* @return void
*/
public function endArray()
{
echo ']';
$this->currentObject = null;
if (count($this->objects)>0) {
$this->currentObject = array_pop($this->objects);
$this->currentObject->comma = ',';
}
}
/**
* Start simple array
*
* @param string $key Used while creating associative array inside an associative array and $key is the key.
* @return void
*/
public function startAssoc($key = null)
{
if ($this->currentObject) {
echo $this->currentObject->comma;
array_push($this->objects, $this->currentObject);
}
$this->currentObject = new JsonEncodeObject('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.It's also worth mentioning that adding charset is fine.
<?php
header('Content-type:application/json;charset=utf-8');
json_encode(['name' => 'Jake', 'country' => 'Philippines']);As json_encode() is recursive, you can use it to serialize whole structure of objects.
<?php
class A {
public $a = 1;
public $b = 2;
public $collection = array();
function __construct(){
for ( $i=3; $i-->0;){
array_push($this->collection, new B);
}
}
}
class B {
public $a = 1;
public $b = 2;
}
echo json_encode(new A);
?>
Will give:
{
"a":1,
"b":2,
"collection":[{
"a":1,
"b":2
},{
"a":1,
"b":2
},{
"a":1,
"b":2
}]
}Please note that there was an (as of yet) undocumented change to the json_encode() function between 2 versions of PHP with respect to JSON_PRETTY_PRINT:
In version 5.4.21 and earlier, an empty array [] using JSON_PRETTY_PRINT would be rendered as 3 lines, with the 2nd one an empty (indented) line, i.e.:
"data": [
],
In version 5.4.34 and above, an empty array [] using JSON_PRETTY_PRINT would be rendered as exactly [] at the spot where it occurs, i.e.
"data: [],
This is not mentioned anywhere in the PHP changelist and migration documentations; neither on the json_encode documentation page.
This is very useful to know when you are parsing the JSON using regular expressions to manually insert portions of data, as is the case with my current use-case (working with JSON exports of over several gigabytes requires sub-operations and insertion of data).> While most decoders will accept these values as valid JSON, some may not, as the specification is ambiguous on this point.
The specification (https://datatracker.ietf.org/doc/html/rfc8259#section-2) is not ambiguous, whether you look at RFC8259, go back to RFC7159 or 7158 or 4627, look at (either edition of) ECMA-404, or even at JSON.org.
The original RFC - from 16 years ago, mind you - specified that the root level of JSON text could only be a object or array.
Literally every other standard - from as long as 9 years ago (RFC7158 and ECMA-404 1st Ed.) and as recent as 5 years ago (RFC8259 and ECMA-404 2nd Ed., both current standards) - makes explicit that any value can appear at the root.For anyone who has run into the problem of private properties not being added, you can simply implement the IteratorAggregate interface with the getIterator() method. Add the properties you want to be included in the output into an array in the getIterator() method and return it.Notice that <?php $json = json_encode($x, JSON_FORCE_OBJECT); ?> doesn't guarantee that $json is actually an object encoded with JSON syntax. It *only* guarantees that the output doesn't start with "[".
For example:
<?php
json_encode("foo", JSON_FORCE_OBJECT); # "foo"
json_encode(42, JSON_FORCE_OBJECT); # 42
json_encode(false, JSON_FORCE_OBJECT); # false
json_encode("false", JSON_FORCE_OBJECT); # "false"
json_encode(10/3, JSON_FORCE_OBJECT); # 3.3333333333333335
?>