PHP using json_php Tutorial

JSON Basics
Simply put, JSON can convert a set of data represented in a JavaScript object into a string, which can then be easily passed between functions, or in an asynchronous application passing a string from a WEB client to a server-side program. The string looks a bit odd (see a couple of examples later), but JavaScript is easy to explain, and JSON can represent a more complex structure than name/value pairs. For example, you can represent arrays and complex objects, not just simple lists of keys and values.
Simple JSON Example
In the simplest form, you can represent name/value pairs using JSON such as the following:

This example is very basic and actually takes up more space than the equivalent plain text name/value pair:

However, when multiple name/value pairs are strung together, JSON reflects its value. First, you can create records that contain multiple name/value pairs, such as:

In terms of syntax, this has no significant advantage over name/value pairs, but in this case JSON is easier to use and more readable. For example, it makes it clear that the above three values are part of the same record, and that the curly braces make some of these values a connection.
Array of values
When you need to represent a set of values, JSON not only improves readability, but also reduces complexity. For example, suppose you want to represent a list of people. In XML, many start and end tags are required, and if you use a typical name/value pair (like the name/value pair you see in the previous article in this series), you must create a proprietary data format or change the key name to a form such as Person1-firstname.
If you use JSON, you only need to group multiple records with curly braces together:

It's not hard to understand. In this example, there is only one variable named people, and the value is an array of three entries, each of which is a person's record with first name, last name, and e-mail address. The above example shows how to combine records into a single value with parentheses. Of course, you can use the same syntax to represent multiple values (each value contains multiple records):

Most notable here is the ability to represent multiple values, each of which in turn contains multiple values. However, it should also be noted that the actual name/value pairs in the record can differ between the different main entries (programmers, authors, and musicians). JSON is completely dynamic, allowing changes in the way the data is represented in the middle of the JSON structure.
There are no predefined constraints to follow when working with JSON-formatted data. So, in the same data structure, you can change the way you represent data, and you can even represent the same thing in different ways.
Using JSON in JavaScript
Once you've mastered the JSON format, it's easy to use it in JavaScript. JSON is a native JavaScript format, which means that working with JSON data in JavaScript does not require any special APIs or toolkits.
Assigning JSON data to a variable
For example, you can create a new JavaScript variable, and then assign the JSON-formatted data string directly to it:

This is very simple; now people contains the JSON-formatted data you saw earlier. However, this is not enough, because the way data is accessed doesn't seem to be obvious.
accessing data
Although it doesn't seem obvious, the long string above is really just an array, and after you put the array into a JavaScript variable, it's easy to access. In fact, you simply represent the array element with a dot notation. So, to access the last name of the first entry in the programmers list, just use the following code in JavaScript:

Note that the array index is zero-based. So, this line of code first accesses the data in the people variable, then moves to the entry called programmers, then moves to the first record ([0]), and finally accesses the value of the LastName key. The result is a string value of "McLaughlin".
Here are a few examples of using the same variable.

With this syntax, you can work with any JSON-formatted data without the need for any additional JavaScript toolkits or APIs.
modifying JSON data
Just as you can access data with dots and parentheses, you can easily modify the data in the same way:

After you convert a string to a JavaScript object, you can modify the data in the variable like this.
Convert back to String
Of course, if the object cannot be easily converted back to the text format mentioned in this article, then all data modifications are not of much value. This conversion is also simple in JavaScript:

It's all right! Now you get 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, you can convert any JavaScript object to JSON text. You can not only handle variables that were originally assigned with a JSON string. In order to convert an object named MyObject, you only need to perform the same form of command:

This is the biggest difference between JSON and other data formats discussed in this series. If you use JSON, just call a simple function, you can get the formatted data, you can use it directly. For other data formats, you need to convert between the original data and the formatted data. Even if you use an API such as the Document Object Model (which provides a function to convert your data structure to text), you need to learn the API and use the object of the API instead of using native JavaScript objects and syntax. The
concludes that JSON is almost certainly a good choice if you are working with a large number of JavaScript objects, which makes it easy to convert the data into a format that can be sent to the server-side program in the request.
JSON application in PHP
The internet today, Ajax is no longer a strange word. Speaking of Ajax, it's possible to immediately think of XML emerging from RSS. XML parsing, I am afraid, is not a problem, especially PHP5, the emergence of a large number of XML parsers, such as the most lightweight simplexml. However, for Ajax, the parsing of XML is more inclined to the support of the foreground JavaScript. I think all the people who parse the XML will have a big head because of the tree and the node. Admittedly, XML is a very good way to store data, but its flexibility has caused the difficulty of its parsing. Of course, the difficulty referred to here is relative to the protagonist--json of this article. What is the
JSON? I will not repeat the concept. In layman's words, it is a storage format for data, just like a string after PHP serialization. It is a data description. For example, when we serialize an array and store it, we can easily deserialize the post-serialization application. The same is true of JSON, except that he builds the interactive bridge between client-side JavaScript and server PHP. We use PHP to generate the JSON string, and then pass the string to the foreground javascript,javascirpt can easily be anti-JSON and then apply. Speaking of popular point, it really looks like an array.
How to use JSON. PHP5.2 starts with the JSON support built in. Of course, if it is lower than this version, then there are many implementations of the PHP version on the market, the next use is OK. Now the main is to talk about PHP built-in support for JSON. Very simple, two functions: Json_encode and Json_decode (much like serialization). One encoding, one decoding. First look at the use of encoding:

$arr = Array (
' Name ' = ' Linux ',
' Nick ' = ' php ',
' Contact ' = = Array (
' Email ' = ' email ',
' website ' = ' http://blog.csdn.net/21aspnet,
)
);
$json _string = Json_encode ($arr);
echo $json _string;
?>
It's very simple to put an array json. It should be pointed out that in the non-UTF-8 encoding, the Chinese characters will not be encode, the result will be null, so if you use gb2312 to write PHP code, then you need to include Chinese content using Iconv or MB to UTF-8 and then Json_encode, I've said it's like serialization, and you don't believe it. After encoding to decode, PHP provides the corresponding function Json_decode,json_decode execution, you will get an object, operation as follows:

$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);
?>
Access properties within an object will it? $obj->name, this, of course, can also be transferred to the array, convenient to call:

$json _string = Json_encode ($arr);
$obj = Json_decode ($json _string);
$arr = (array) $obj;
Print_r ($arr);
The use of PHP is not particularly large, in addition to cache generation, the feeling is not as good as the direct storage array, but when you interact with the foreground, it is out of the way, see how I used JavaScript to use this character.
Above, directly assign this string to a variable, it becomes a JavaScript array (professional terminology should not be called an array, but because of the habit of PHP, I have been called array good, easy to understand). In this way, you can easily traverse arr or do whatever you want. It doesn't seem to mention Ajax in this case? Yes, Lenovo, if the responsetext returned by the server replaces XML with a JSON string, is it convenient for the foreground JavaScript to be processed? That's how Dogskin plaster is used.
Actually written here, in addition to the data storage format is not the same, JSON and XML is not much different, oh, but I said the next point. Although it does not have much to do with XML, it is possible to describe a wider range of applications for JSON, that is, cross-domain data invocation. Because of security issues, Ajax does not support cross-domain calls, so to invoke different domain names under the data, very troublesome Oh, although there is a solution (stone in his lecture mentioned the agent ah what although not understand but know can solve). I wrote two files that were enough to show cross-domain calls.
Keynote file index.html



Transferred Files profile.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 in as a parameter to the GetProfile, and then the nickname is inserted into the Div, so that the cross-domain data interaction is complete and is not particularly straightforward. Since JSON is so easy to use and useful, what are you waiting for? ^_^


Excerpt from the Bangs column
ZZ

http://www.bkjia.com/PHPjc/478336.html www.bkjia.com true http://www.bkjia.com/PHPjc/478336.html techarticle The JSON Foundation simply says that JSON can convert a set of data represented in a JavaScript object into a string, which can then be easily passed between functions, or asynchronously ...

