Chuyển array thành json string
Array thành json string
$user = [
'id' => 1,
'username' => 'admin',
];
echo json_encode[$user];Kết quả:
{"id":1,"username":"admin"}
Nếu muốn format đẹp hơn ta cho thêm tham số:
echo json_encode[$user, JSON_PRETTY_PRINT];
Kết quả:
{
"id": 1,
"username": "admin"
}Chuyển ngược lại json string thành array
Cách thực hiện đơn giản như sau:
$json = '{"id":1,"username":"admin"}';
$user = json_decode[$json, true];Tham số thứ 2 true của hàm json_decode là để hàm trả về kết quả là array.
Chuyển Object thành json string
Encode
Ta giả sử có class user như sau:
class User {
public $id;
public $username;
}Sử dụng class như sau:
$user = new User[];
$user->id = 1;
$user->username = 'admin';
echo json_encode[$user];Ta cũng sẽ được kết quả tương tự như trên:
`{"id":1,"username":"admin"}
Decode
Vậy làm sao để decode được json to object của class User Có khá nhiều cách nhưng cách đơn giản và hiệu quả nhất như sau:
// Khai báo class
class User {
public $id;
public $username;
}
// json string
$json = '{"id":1,"username":"admin"}';
// thực hiện decode như ở trên
$data = json_decode[$json, true];
// tạo object User
$user = new User[];
// Gắn dữ liệu vào object User
foreach [$data as $key => $value] {
$user->{$key} = $value;
}
// Thu được kết quả
var_export[$user];Kết quả:
User::__set_state[array[
'id' => 1,
'username' => 'admin',
]]---
Phuc Tran Hoang
[PHP 5 >= 5.2.0, PHP 7, PHP 8, PECL json >= 1.2.0]
json_encode — Returns the JSON representation of a value
Description
json_encode[mixed $value,
int $flags = 0, int $depth = 512]: string|false
If a value to be serialized is an object, then by default only publicly visible properties will be included. Alternatively, a class may implement JsonSerializable to control how its values are serialized to JSON.
The encoding is affected by the supplied flags and additionally the encoding of float values depends on the value of serialize_precision.
Parameters
value The value being encoded. Can be any type except a
resource.
All string data must be UTF-8 encoded.
Note:
PHP implements a superset of JSON as specified in the original » RFC 7159.
flags Bitmask consisting of 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. The behaviour of these constants is described on the JSON constants page.
depthSet the maximum depth. Must be greater than zero.
Return Values
Returns a JSON encoded string on success or false on failure.
Changelog
| 7.3.0 | JSON_THROW_ON_ERROR flags was added.
|
| 7.2.0 | JSON_INVALID_UTF8_IGNORE, and JSON_INVALID_UTF8_SUBSTITUTE flags were added.
|
| 7.1.0 | JSON_UNESCAPED_LINE_TERMINATORS flags was added.
|
| 7.1.0 | serialize_precision is used instead of precision when encoding double values. |
Examples
Example #1 A json_encode[] example
The above example will output:
{"a":1,"b":2,"c":3,"d":4,"e":5}
Example #2 A json_encode[] example showing some flags in use
The above example will output:
Normal: ["","'bar'","\"baz\"","&blong&","\u00e9"]
Tags: ["\u003Cfoo\u003E","'bar'","\"baz\"","&blong&","\u00e9"]
Apos: ["","\u0027bar\u0027","\"baz\"","&blong&","\u00e9"]
Quot: ["","'bar'","\u0022baz\u0022","&blong&","\u00e9"]
Amp: ["","'bar'","\"baz\"","\u0026blong\u0026","\u00e9"]
Unicode: ["","'bar'","\"baz\"","&blong&","é"]
All: ["\u003Cfoo\u003E","\u0027bar\u0027","\u0022baz\u0022","\u0026blong\u0026","é"]
Empty array output as array: []
Empty array output as object: {}
Non-associative array output as array: [[1,2,3]]
Non-associative array output as object: {"0":{"0":1,"1":2,"2":3}}
Associative array always output as object: {"foo":"bar","baz":"long"}
Associative array always output as object: {"foo":"bar","baz":"long"}
Example #3 JSON_NUMERIC_CHECK option example
The above example will output something similar to:
Strings representing numbers automatically turned into numbers
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]"
Strings containing improperly formatted numbers
array[2] {
[0]=>
string[13] "+a33123456789"
[1]=>
string[4] "a123"
}
string[24] "["+a33123456789","a123"]"
Example #4 Sequential versus non-sequential array example
The above example will output:
Sequential 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"]"
Non-sequential 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"}"
Sequential array with one key unset
array[3] {
[0]=>
string[3] "foo"
[2]=>
string[3] "baz"
[3]=>
string[5] "blong"
}
string[33] "{"0":"foo","2":"baz","3":"blong"}"
Example #5 JSON_PRESERVE_ZERO_FRACTION option
example
The above example will output:
string[4] "12.0" string[2] "12"
Notes
Note:
In the event of a failure to encode, json_last_error[] can be used to determine the exact nature of the error.
Note:
When encoding an array, if the keys are not a continuous numeric sequence starting from 0, all keys are encoded as strings, and specified explicitly for each key-value pair.
Note:
Like the reference JSON encoder, json_encode[] will generate JSON that is a simple value [that is, neither an object nor an array] if given a string, int, float or bool as an input
value. While most decoders will accept these values as valid JSON, some may not, as the specification is ambiguous on this point.To summarise, always test that your JSON decoder can handle the output you generate from json_encode[].
See Also
- JsonSerializable
- json_decode[] - Decodes a JSON string
- json_last_error[] - Returns the last error occurred
- serialize[] - Generates a storable representation of a value
bohwaz ¶
10 years ago
Are you sure you want to use JSON_NUMERIC_CHECK, really really sure?
Just watch this usecase:
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!
DimeCadmium ¶
8 months ago
> While most decoders will accept these values as valid JSON, some may not, as the specification is ambiguous on this point.
The specification [//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.
ryan at ryanparman dot com ¶
12 years ago
I came across the "bug" where running json_encode[] over a SimpleXML object was ignoring the CDATA. I ran across //bugs.php.net/42001 and //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.
Nick ¶
6 years ago
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].
guilhenfsu at gmail dot com ¶
9 years ago
Solution for UTF-8 Special Chars.
ck at ergovia dot de ¶
9 years ago
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];
Walter Tross ¶
6 years ago
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];
Istratov Vadim ¶
13 years ago
Be careful with floating values in some locales [e.g. russian] with comma [","] as decimal point. Code:
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.
jakepucan at gmail dot com ¶
1 year ago
It's also worth mentioning that adding charset is fine.