Parsing a JSON file or string is just as easy as parsing XML once you get the syntax, and in this tutorial I’ll show you how to parse and learn its syntax. But before we begin let’s establish some naming conventions for PHP arrays just in case you don’t know them already.
Take a look at the following PHP array.
$arrayName[key]=value;
Arrays in PHP have three parts, the name or variable used, the key ( can be associative or numeric) and the value of that key.
When we read/parse a json string or file with PHP what we will be doing is basically assigning a bunch of keys to a variable and so that variable will become an associative array. In case you haven’t heard the terms associative or numeric, numeric simply means that you are using numbers as keys.
Now that we got a convention let’s look at a simple JSON string.
$string='{"name":"John Adams"}';
You can think of this string as a key “name” that holds the value “John Adams”. Notice the brackets, they are used to separate arrays of keys. So we can give the following naming convention to this json string
{"key":"value"}
To parse JSON with PHP we will be using the funcion json_decode , this function takes a json string for its first parameter and an optional boolean (true/false) for its second parameter. The second parameter, if set to true, returns the json string as an associative array, if it’s not set it will return an object. The main difference between the two options is the syntax you use to refer to keys, for now we’ll be setting the second parameter to true so that it returns the more familiar associative array, but we will cover objects.
Now that you know about this new function make your php file look like mine.
$string='{"name":"John Adams"}';
$json_a=json_decode($string,true);
Using json_decode with the second parameter set to true we have assigned an associative array to the variable $json_a, so $json_a is now an array. I use “_a” to refer to an associative array, we’ll later use $json_o to refer to a variable that holds the json as an object but you can use whatever variable name you want.
Let me translate the code above to a more familar and basic snippet that is doing the same thing.
$json_a=array("name"=>"John Adams");
// or also
$json_a["name"]="John Adams";
Now it’s clear what you can do with “$json_a” right? To show contents of “name” you would simply echo $json_a[name] like this
echo $json_a[name]; // and you should see the name John Adams printed on your browser.
That was easy, now let’s use the same json string but this time we won’t set the second parameter so that we can get an object. Fill your php file with the following code.
$string='{"name":"John Adams"}';
$json_o=json_decode($string);
This time instead of returning an array, json_decode has returned an object. The word object might sound a little intimidating but believe me when I say this isn’t hard at all.
To show the contents of “name” all one has to do is this
echo $json_o->name;
Can you tell the difference between outputting $json_a and $json_o’s content? That’s right! the only difference is that with $json_o you get rid of the leading “]” and replace “[” with “->”.
echo $json_a[name]; // and echo $json_o->name; // will both display "John Adams"
The json string we’ve been using is very simple so am going to make it a little more interesting. The content of your php file up to this point should be this
$string='{"name":"John Adams"}';
// create object from string
$json_o=json_decode($string);
// create array from string
$json_a=json_decode($string,true);
Whenever I make changes to the value of your $string variable keep the last two lines with json_decode for the rest of this tutorial.
$string='{
"name":"John Adams",
"age":"40"
}';
$json_o=json_decode($string);
$json_a=json_decode($string,true);
As you might guess from the the new way $string looks, you separate each set of keys and values with a comma. So to display to value of age, which is 40, you can use either of these two methods.
// associative array mode echo $json_a[age]; // object mode echo $json_o->age;
But this JSON string is still too simple, why don’t we assign two keys to a key. Then new json string will be this.
$string='{
"name":{"first":"John","last":"Adams"},
"age":"40"
}';
What we’ve done is we have separated the name “John Adams” into two “subkeys;” , first and last. We can display the values of these new keys this way.
// array method // display first name echo $json_a[name][first]; // display last name echo $json_a[name][last]; // object method // display first name echo $json_o->name->first; // display last name echo $json_o->name->last;
So far so good. You have probably seen the symbols [ and ] used in json and if you haven’t you will right now because that’s what our new $string variable will include.
$string='[
{
"name":{"first":"John","last":"Adams"},
"age":"40"
},
{
"name":{"first":"Thomas","last":"Jefferson"},
"age":"35"
}
]';
We use [ and ] to indicate that we have an array of keys, that is more than one set of { }’s. That means then, that this string has two arrays , each of them separated by { and } and followed by a comma except for the last one. This array is numeric, so to access “age” in the second array we’ll do the following.
// remember that arrays start at zero, that's why we use 1 to refer to the second array // array method echo $json_a[1][age]; // object method echo $json_o[1]->age;
In your web development career you will encounter yet another type of json string.
$string='{"person":
[
{
"name":{"first":"John","last":"Adams"},
"age":"40"
},
{
"name":{"first":"Thomas","last":"Jefferson"},
"age":"35"
}
]
}';
This string is just like the previous one except that we have added {“person”: at the beginning and to close, we added a } at the end.
What we have here is two “person” arrays one for John and one for Thomas. You can display both last names with this snippet of code.
// array method
// first person "0"
echo $json_a[person][0][name][last];
// second person "1"
echo $json_a[person][1][name][last];
// object method
// first person "0"
echo $json_o->person[0]->name->last;
// second person "1"
echo $json_o->person[1]->name->last;
It all seems fine, until we have a 100 “person” array or more! But don’t worry. Because these arrays are numeric we can use a loop to go through a huge array like that. I like to use “foreach” loops but you can use “while”, “for” or “do while” loops if you want. The next snippet will show you how you can get each person’s information using a foreach loop.
$string='{"person":[
{
"name":{"first":"John","last":"Adams"},
"age":"40"
},
{
"name":{"first":"Thomas","last":"Jefferson"},
"age":"35"
}
]}';
$json_a=json_decode($string,true);
$json_o=json_decode($string);
// array method
foreach($json_a[person] as $p)
{
echo '
Name: '.$p[name][first].' '.$p[name][last].'
Age: '.$p[age].'
';
}
// object method
foreach($json_o->person as $p)
{
echo '
Name: '.$p->name->first.' '.$p->name->last.'
Age: '.$p->age.'
';
}
Reading a JSON is just as easy and it does not have a special extension, the file just has to output a json string. To read a JSON file you can use the function file_get_contents like this $string=file_get_contents(filepath) . Now pass $string to json_decode and parse.