Php json from variable

PHP Json_encode: Serialize PHP Objects to JSON

PHP is a server-side scripting language for creating your website’s backend system that can serve webpages, communicate with databases, and exchange data over the internet. A decent backend framework like PHP needs to be capable of providing and processing data in any format (e.g., XML, JSON, etc.) to be socially accepted in a society of skilled web development frameworks.

Since JSON is a ubiquitous data format for sharing and storing data, it is vital that a PHP backend allows processing of JSON data. This is where json_encode (and json_decode) come into the picture and enable PHP processed data to be compatible with frameworks and systems that deal with JSON data and make way for easier and faster web development.

In this post, we’ll learn about the JSON format, about the json_encode() function — what it is, why it is required, and how it can be used to convert PHP data structures into JSON format, all with examples. In the end, we’ll also see how we can decode JSON data to be able to process it. Let’s get started!

Use these links to navigate the guide:

What is the JSON_Encode Function?

What is JSON?

JSON (JavaScript Object Notation) is one of the most popular open-standard file formats used for storing and sharing data. It uses human-readable text to represent data using attribute-value pairs and array data types.

This is what a common JSON object looks like —

We’ll be using this example in the sections below to understand how we can encode PHP data into JSON format.

JSON allows us to represent and encapsulate complex data in an organized fashion that can be shared easily across the internet. Even though JSON derives its name from JavaScript, JSON was created to be used by all programming languages.

Let’s see how we can convert our PHP variables into JSON format.

JSON_Encode — PHP variables to JSON

json_encode() is a native PHP function that allows you to convert PHP data into the JSON format.

json_encode ( mixed $value [, int $options = 0 [, int $depth = 512 ]] ) : string 

The function takes in a PHP object ($value) and returns a JSON string (or False if the operation fails). Don’t worry about the $options and $depth parameters; you’re seldom going to need them.

Let’s look at a simple example —

 1, 'b' => 2); echo json_encode($arr); ?>

Why encode to JSON?

As we saw above, JSON is one of the most common formats for exchanging data over the internet. Therefore, it can be imperative in some cases for PHP servers to provide JSON-encoded data and to be able to process it.

Let’s see how we can encode various PHP data structures into JSON using json_encode() .

Convert PHP Strings to JSON

JSON encoding for a string is the string itself. Therefore, encoding a PHP string into JSON is quite simple; it results in the same string being returned.

Let’s see this using an example —

PHP String to JSON Example

Convert PHP Objects to JSON

Since the information in JSON is stored in key/value pairs, json_encode() is more likely to be used to encode PHP objects and their instance variables.

PHP Object to JSON Example

Let’s understand how we can JSON-encode a PHP object by creating an instance of a Book class based on the Library example we saw above (Sec 1.1). We’ll create two instance variables for the book’s instance and encode the object using json_encode().

 $book = new Book(); $book->id = 101; $book->label = "Lorem ipsum"; $jsonData = json_encode($book); echo $jsonData."\n"; ?>

Convert PHP Array to JSON

There are three types of arrays in PHP, namely — Indexed arrays, Associative arrays, and Multidimensional arrays. Let us look at what these are and some examples of how we can encode each of these into JSON —

Indexed Array to JSON

Indexed arrays are conventional arrays that are represented by index numbers.

Example: $arr = array(1,2,3,4); // [1,2,3,4]

Converting them to JSON is quite easy —

Associative Array to JSON

Associative arrays are arrays that use named keys as indices for your values.

Example: $age = array(«John»=>»11», «Ken»=>»19», «Tim»=>»14»);

We can also arrive at the book JSON object that we saw above by encoding an Associative array as such —

101, "label"=>"Lorem Ipsum"); echo json_encode($book); ?>

Notice how an Indexed array is represented by an array in JSON, whereas Associative arrays take the form of a complete JSON object after being encoded.

Multidimensional Array to JSON

Multidimensional arrays can be created by nesting arrays into each other as such-

$multid_arr = array( array(1,2,3,4), array(1,2,3,4), ); 

We can create a Multidimensional array to store a list of books for our library example. Let’s create one and encode that into JSON.

101, "label"=>"Lorem Ipsum"), array("id"=>102, "label"=>"Dolor sir amet"), array("id"=>103, "label"=>"Lorem Ipsum dolor"), ); echo json_encode($books); ?>

Putting it all together

Now that we have seen how json_encode( ) is used in different contexts, for encoding different PHP data types, let’s put all of our learnings together to create JSON data for the Library example we saw above.

 class Library < >class Book < >$book1 = new Book(); $book1->id = 101; $book1->label = "Lorem ipsum"; $book2 = new Book(); $book2->id = 102; $book2->label = "Dolor sir amet"; $books = array($book1, $book2); $library = new Library(); $library->books = $books; $myClass = new MyClass(); $myClass->library = $library; $jsonData = json_encode($myClass); echo $jsonData."\n"; 

Well, that was fun! Now before we wrap up, I think it’s worthwhile to see how we can convert JSON data back to PHP variables.

JSON_Decode — JSON to PHP variables

In the very likely case of your JavaScript front-end sending JSON-based data back to your PHP server, you would need a way to decode the JSON data in a way that can be processed by PHP.

We can use PHP’s json_decode() function for the same, which takes in a JSON encoded string and returns the corresponding PHP variable.

json_decode ( string $json [, bool $assoc = FALSE [, int $depth = 512 [, int $options = 0 ]]] ) : mixed

$assoc parameter (False by default) is used to specify whether you need the function to return an Associative array or a standard class Object.

JSON_Decode example

Let’s try to retrieve the book object that we encoded into JSON above by decoding it using php_decode() .

'; $book = json_decode($book_json); var_dump($book); ?>

Note how by default a stdClass object is returned. For decoding it as an Associative array, set the $assoc parameter to True as such —

$book = json_decode($book_json, True);

This will result in an Associative array being returned.

Try the JSON_Encode Function for Yourself

In this post, we read about the JSON (JavaScript Object Notation) format, why it is essential, and how we can convert different PHP variables into JSON using json_encode() . We also saw how we could use json_decode() to decode JSON data into PHP variables. With this understanding of processing JSON data using PHP, go ahead and encode your PHP objects into JSON and share them across the internet. All of this while staying at home. Stay healthy, stay safe!

Get peace of mind knowing your PHP application is performing at its best with ScoutAPM

Most popular

Follow Us on Social Media!

Источник

json_decode

Takes a JSON encoded string and converts it into a PHP value.

Parameters

The json string being decoded.

This function only works with UTF-8 encoded strings.

Note:

PHP implements a superset of JSON as specified in the original » RFC 7159.

When true , JSON objects will be returned as associative array s; when false , JSON objects will be returned as object s. When null , JSON objects will be returned as associative array s or object s depending on whether JSON_OBJECT_AS_ARRAY is set in the flags .

Maximum nesting depth of the structure being decoded. The value must be greater than 0 , and less than or equal to 2147483647 .

Bitmask of JSON_BIGINT_AS_STRING , JSON_INVALID_UTF8_IGNORE , JSON_INVALID_UTF8_SUBSTITUTE , JSON_OBJECT_AS_ARRAY , JSON_THROW_ON_ERROR . The behaviour of these constants is described on the JSON constants page.

Return Values

Returns the value encoded in json in appropriate PHP type. Values true , false and null are returned as true , false and null respectively. null is returned if the json cannot be decoded or if the encoded data is deeper than the nesting limit.

Errors/Exceptions

If depth is outside the allowed range, a ValueError is thrown as of PHP 8.0.0, while previously, an error of level E_WARNING was raised.

Changelog

Version	Description
7.3.0	JSON_THROW_ON_ERROR flags was added.
7.2.0	associative is nullable now.
7.2.0	JSON_INVALID_UTF8_IGNORE , and JSON_INVALID_UTF8_SUBSTITUTE flags were added.
7.1.0	An empty JSON key («») can be encoded to the empty object property instead of using a key with value _empty_ .

Examples

Example #1 json_decode() examples

var_dump ( json_decode ( $json ));
var_dump ( json_decode ( $json , true ));

The above example will output:

object(stdClass)#1 (5) < ["a"] =>int(1) ["b"] => int(2) ["c"] => int(3) ["d"] => int(4) ["e"] => int(5) > array(5) < ["a"] =>int(1) ["b"] => int(2) ["c"] => int(3) ["d"] => int(4) ["e"] => int(5) >

Example #2 Accessing invalid object properties

Accessing elements within an object that contain characters not permitted under PHP’s naming convention (e.g. the hyphen) can be accomplished by encapsulating the element name within braces and the apostrophe.

$obj = json_decode ( $json );
print $obj ->< 'foo-bar' >; // 12345

Example #3 common mistakes using json_decode()

// the following strings are valid JavaScript but not valid JSON

// the name and value must be enclosed in double quotes
// single quotes are not valid
$bad_json = «< 'bar': 'baz' >» ;
json_decode ( $bad_json ); // null

// the name must be enclosed in double quotes
$bad_json = ‘< bar: "baz" >‘ ;
json_decode ( $bad_json ); // null

// trailing commas are not allowed
$bad_json = ‘< bar: "baz", >‘ ;
json_decode ( $bad_json ); // null

Example #4 depth errors

// Encode some data with a maximum depth of 4 (array -> array -> array -> string)
$json = json_encode (
array(
1 => array(
‘English’ => array(
‘One’ ,
‘January’
),
‘French’ => array(
‘Une’ ,
‘Janvier’
)
)
)
);

// Show the errors for different depths.
var_dump ( json_decode ( $json , true , 4 ));
echo ‘Last error: ‘ , json_last_error_msg (), PHP_EOL , PHP_EOL ;

var_dump ( json_decode ( $json , true , 3 ));
echo ‘Last error: ‘ , json_last_error_msg (), PHP_EOL , PHP_EOL ;
?>

The above example will output:

array(1) < [1]=>array(2) < ["English"]=>array(2) < [0]=>string(3) "One" [1]=> string(7) "January" > ["French"]=> array(2) < [0]=>string(3) "Une" [1]=> string(7) "Janvier" > > > Last error: No error NULL Last error: Maximum stack depth exceeded

Example #5 json_decode() of large integers

var_dump ( json_decode ( $json ));
var_dump ( json_decode ( $json , false , 512 , JSON_BIGINT_AS_STRING ));

The above example will output:

object(stdClass)#1 (1) < ["number"]=>float(1.2345678901235E+19) > object(stdClass)#1 (1) < ["number"]=>string(20) "12345678901234567890" >

Notes

Note:

The JSON spec is not JavaScript, but a subset of JavaScript.

Note:

In the event of a failure to decode, json_last_error() can be used to determine the exact nature of the error.

See Also

User Contributed Notes 8 notes

JSON can be decoded to PHP arrays by using the $associative = true option. Be wary that associative arrays in PHP can be a «list» or «object» when converted to/from JSON, depending on the keys (of absence of them).

You would expect that recoding and re-encoding will always yield the same JSON string, but take this example:

$json = »;
$array = json_decode($json, true); // decode as associative hash
print json_encode($array) . PHP_EOL;

This will output a different JSON string than the original:

The object has turned into an array!

Similarly, a array that doesn’t have consecutive zero based numerical indexes, will be encoded to a JSON object instead of a list.

$array = [
‘first’,
‘second’,
‘third’,
];
print json_encode($array) . PHP_EOL;
// remove the second element
unset($array[1]);
print json_encode($array) . PHP_EOL;

The array has turned into an object!

In other words, decoding/encoding to/from PHP arrays is not always symmetrical, or might not always return what you expect!

On the other hand, decoding/encoding from/to stdClass objects (the default) is always symmetrical.

Arrays may be somewhat easier to work with/transform than objects. But especially if you need to decode, and re-encode json, it might be prudent to decode to objects and not arrays.

If you want to enforce an array to encode to a JSON list (all array keys will be discarded), use:

If you want to enforce an array to encode to a JSON object, use:

Источник