Php uses json

JSON Basics
Simply put, JSON can convert a set of data represented in a JavaScript object to a string, and then it can be easily passed between functions, alternatively, the string is transmitted from the Web Client to the server in an asynchronous application. This string looks a bit odd (several examples will be seen later), but JavaScript can easily explain it, and JSON can represent a more complex structure than name/value pairs. For example, it can represent arrays and complex objects, not just a simple list of keys and values.
Simple JSON example
In the simplest form, you can use the following JSON to represent name/value pairs:

 
This example is very basic and actually takes more space than the equivalent plain text name/Value Pair:

 
However, when multiple name/value pairs are concatenated, JSON will reflect its value. First, you can create records that contain multiple name/value pairs, for example:

 
In terms of syntax, this is not a great advantage over name/value pairs, but JSON is easier to use and more readable in this case. For example, it explicitly indicates that the above three values are part of the same record; curly braces make these values have a certain relationship.
Array of Values
To represent a group of values, JSON not only improves readability, but also reduces complexity. For example, assume that you want to list a person's name. In XML, many start and end tags are required. If a typical name/value pair is used (like the name/value pair seen in the previous articles in this series ), you must either create a proprietary data format or change the key name to a person1-firstName.
If JSON is used, you only need to group multiple records with curly braces:

 
This is not hard to understand. In this example, there is only one variable named people. The value is an array containing three entries, each of which is a one-person record, including the name, last name, and email address. The preceding example demonstrates how to use parentheses to combine records into a value. Of course, you can use the same syntax to represent multiple values (each value contains multiple records ):

 
It is worth noting that each value can contain multiple values. However, you should also note that the actual name/value pairs in the record can be different between different primary entries (programmers, authors, and musicians. JSON is completely dynamic and allows you to change the data representation mode in the middle of the JSON structure.
When processing data in JSON format, there are no predefined constraints to be observed. Therefore, in the same data structure, you can change the way data is represented, or even express the same thing in different ways.
Use JSON in JavaScript
After mastering the JSON format, it is easy to use it in JavaScript. JSON is a JavaScript native format, which means that no special API or toolkit is required to process JSON data in JavaScript.
Assign JSON data to a variable
For example, you can create a new JavaScript variable and assign a value to the JSON-format data string:

 
This is very simple; now people contains the data in JSON format as shown above. However, this is not enough, because the data access method does not seem obvious.
Access Data
Although the above long string is actually an array, the array can be easily accessed after it is put into JavaScript variables. In fact, you only need to use the dot notation to represent array elements. Therefore, to access the first project name in the programmers list, you only need to use the following code in JavaScript:

 
Note that the array index starts from scratch. Therefore, this line of code first accesses the data in the people variable, then moves to the entry called programmers, and then to the first record ([0]). Finally, it accesses the value of the lastName key. The result is the string value "McLaughlin ".
The following are examples of using the same variable.

 
With this syntax, You can process data in any JSON format without using any additional JavaScript toolkit or API.
Modify JSON data
Just as you can access data with periods and parentheses, you can easily modify the data in the same way:

 
After converting a string to a JavaScript Object, you can modify the data in the variable as follows.
Convert back to string
Of course, if you cannot easily convert an object back to the text format mentioned in this article, all data modifications are of little value. In JavaScript, this conversion is also very simple:

 
That's all! Now you can obtain a text string that can be used anywhere. For example, you can use it as a request string in an Ajax application. Www.2cto.com
More importantly, any JavaScript Object can be converted to JSON text. It is not only applicable to variables that are originally assigned values using JSON strings. To convert an object named myObject, you only need to execute the same command:

 
This is the biggest difference between JSON and other data formats discussed in this series. If JSON is used, you only need to call a simple function to obtain formatted data and use it directly. For other data formats, the conversion between the original data and the formatted data is required. Even if you use an API like Document Object Model (which provides a function to convert your data structure to text), you also need to learn this API and use the Object of the API, instead of using native JavaScript objects and syntaxes.
The final conclusion is that if you want to process a large number of JavaScript objects, JSON is almost certainly a good choice, so that you can easily convert the data to a format that can be sent to the server-side program in the request.
Application of JSON in PHP
Today, AJAX is no stranger to the Internet. When talking about AJAX, you may immediately think of XML that has emerged due to RSS. XML parsing is no longer a problem, especially PHP5. A large number of XML Parser emerged, such as SimpleXML, which is the most lightweight. However, for AJAX, XML parsing tends to support Javascript at the front end. I think all the people who have parsed XML will be headers of trees and nodes. It is undeniable that XML is a good data storage method, but its flexibility has caused difficulties in parsing. Of course, the difficulty mentioned here is relative to JSON, the main character of this article.
What is JSON? I will not repeat the concept. In general, it is a data storage format, just like the serialized string in PHP. It is a data description. For example, if we store an array after serialization, we can easily apply it after deserialization. JSON is the same, but it builds a bridge between client Javascript and server PHP. We use PHP to generate the JSON string, and then pass the string to the front-end Javascript. Then we can easily apply the Javascirpt anti-JSON string. It is really like an array.
To put it bluntly, how to use JSON. PHP5.2 has built-in support for JSON. Of course, if it is earlier than this version, there are many PHP versions available on the market, and it will be OK as soon as the next version is used. Now we mainly talk about the built-in JSON supported by PHP. Very simple: two functions: json_encode and json_decode (similar to serialization ). One encoding and one decoding. Let's take a look at the encoding usage:

<? Php
$ Arr = array (
'Name' => 'linux ',
'Nick '=> 'php ',
'Contact '=> array (
'Email '=> 'email ',
'Website' => 'HTTP: // blog.csdn.net/21aspnet,
)
);
$ Json_string = json_encode ($ arr );
Echo $ json_string;
?>
Simply put an array in JSON format. It should be noted that, in non-UTF-8 encoding, Chinese characters will not be encode, the results will be null, So if you use gb2312 to write PHP code, then you need to use iconv or mb to convert the content containing Chinese characters into a UTF-8 and then perform json_encode. I have said it is similar to serialization, you do not believe it. Decoding is required after encoding. PHP provides the corresponding function json_decode. After json_decode is executed, an object is obtained. The operation is as follows:

<? Php
$ Arr = array (
'Name' => 'linux ',
'Nick '=> 'php ',
'Contact '=> array (
'Email '=> 'email ',
'Website' => 'HTTP: // blog.csdn.net/21aspnet,
)
);
$ Json_string = json_encode ($ arr );
$ Obj = json_decode ($ json_string );
Print_r ($ obj );
?>
Will access the attributes in the object? $ Obj-> name. Of course, you can also index the array to facilitate the call:

$ Json_string = json_encode ($ arr );
$ Obj = json_decode ($ json_string );
$ Arr = (array) $ obj;
Print_r ($ arr );
PHP transfer and transfer are not very useful. In addition to cache generation, it feels better to store arrays directly. However, when you interact with the front-end, the function will come out, next let's take a look at how I use Javascript to use this character.
In the above, the string is directly assigned to a variable, and it becomes a Javascript Array (specialized terms should not be called arrays, but due to the habits of PHP, I have been calling Arrays for ease of understanding ). In this way, you can easily traverse the arr or do whatever you want. It seems that AJAX is not mentioned here? Yes. In retrospect, if the server returns responseText with a JSON string instead of XML, will the front-end Javascript processing be very convenient? Dog Skin plaster is used in this way.
As a matter of fact, apart from the different storage formats of data, there is no big difference between JSON and XML. Although it does not have much to do with XML, it can indicate a wider range of JSON applications, that is, cross-Origin data calls. Due to security issues, AJAX does not support cross-origin calls. Therefore, it is very troublesome to call data under different domain names, although there is a solution (stone mentioned proxy in his lecture. Although he doesn't understand it, he knows it can solve it ). I wrote two files to demonstrate cross-origin calls.
Access key file index.html
<Script type = "text/javascript">
Function getProfile (str ){
Var arr = str;
Document. getElementById ('Nick '). innerHTML = arr. nick;
}
</Script>
<Body> <div id = "nick"> </div> </body>
<Script type = "text/javascript" src = "profile. php"> </script>
Profile. php
<? Php
$ Arr = array (
'Name' => 'linux ',
'Nick '=> 'php ',
'Contact '=> array (
'Email '=> 'email ',
'Website' => 'HTTP: // blog.csdn.net/21aspnet,
)
);
$ Json_string = json_encode ($ arr );
Echo "getProfile ($ json_string )";
?>
Obviously, when index.html calls profile. php, The JSON string is generated and passed into getProfile as a parameter, and then the nickname is inserted into the div. This completes a cross-Origin data interaction. Is it very simple. Since JSON is so easy to use and easy to use, what are you waiting? Pai_^


From the column by Liu haicao
Zz