PHP Variables Dumping Variable Contents as Strings

PHP Variables

Dumping Variable Contents as Strings

Problem

You want to inspect the values stored in a variable. It may be a complicated nested array or object, so you can’t just print it out or loop through it.

Solution

Use var_dump(), print_r(), or var_export(), depending on exactly what you need. The var_dump() and print_r() functions provide different human-readable representations of variables. The print_r() function is a little more concise:

           $info = array('name' => 'frank', 12.6, array(3, 4));
           print_r($info);

prints:

           Array
           (
                   [name] => frank
                   [0] => 12.6
                   [1] => Array
                          (
                                 [0] => 3
                                 [1] => 4
                          )
           )

While this:

           $info = array('name' => 'frank', 12.6, array(3, 4));
           var_dump($info);

prints:

           array(3) {
                   ["name"]=>
                   string(5) "frank"
                   [0]=>
                   float(12.6)
                   [1]=>
                   array(2) {
                          [0]=>
                          int(3)
                          [1]=>
                          int(4)
                   }
           }

The var_export() function produces valid PHP code that, when executed, defines the exported variable:

            $info = array('name' => 'frank', 12.6, array(3, 4));
            var_export($info);

prints:

            array (
                   'name' => 'frank',
                   0 => 12.6,
                   1 =>
                   array (
                          0 => 3,
                          1 => 4,
                   ),
            )

Discussion

The three functions mentioned in the Solution differ in how they handle recursion in references. Because these functions recursively work their way through variables, if you have references within a variable pointing back to the variable itself, you would end up with an infinite loop unless these functions bailed out.

When var_dump() or print_r() has seen a variable once, it prints *RECURSION* instead of printing information about the variable again and continues iterating through the rest of the information it has to print. The var_export() function does a similar thing, but it prints null instead of *RECURSION* to ensure its output is executable PHP code.

Consider the arrays $user_1 and $user_2, which reference each other through their friend elements:

            $user_1 = array('name' => 'Max Bialystock',
                                      'username' => 'max');

            $user_2 = array('name' => 'Leo Bloom',
                                      'username' => 'leo');

            // Max and Leo are friends
            $user_2['friend'] = &$user_1;
            $user_1['friend'] = &$user_2;

            // Max and Leo have jobs
            $user_1['job'] = 'Swindler';
            $user_2['job'] = 'Accountant';

The output of print_r($user_2) is:

            Array
            (
                    [name] => Leo Bloom
                    [username] => leo
                    [friend] => Array
                           (
                                    [name] => Max Bialystock
                                    [username] => max
                                    [friend] => Array
                                            (
                                                    [name] => Leo Bloom
                                                    [username] => leo
                                                    [friend] => Array

                *RECURSION*
                                                    [job] => Accountant
                                            )
                                    [job] => Swindler
                           )
                    [job] => Accountant
            )

When print_r() sees the reference to $user_1 the second time, it prints *RECURSION* instead of descending into the array. It then continues on its way, printing the remaining elements of $user_1 and $user_2. The var_dump() function behaves similarly:

            array(4) {
                   ["name"]=>
                   string(9) "Leo Bloom"
                   ["username"]=>
                   string(3) "leo"
                   ["friend"]=>
                   &array(4) {
                         ["name"]=>
                         string(14) "Max Bialystock"
                         ["username"]=>
                         string(3) "max"
                         ["friend"]=>
                         &array(4) {
                                ["name"]=>
                                string(9) "Leo Bloom"
                                ["username"]=>
                                string(3) "leo"
                                ["friend"]=>
                                *RECURSION*
                                ["job"]=>
                                string(10) "Accountant"
                         }
                         ["job"]=>
                         string(8) "Swindler"
                   }
                   ["job"]=>
                   string(10) "Accountant"
           }

As does var_export(), but with null instead of *RECURSION*:

           array (
                   'name' => 'Leo Bloom',
                   'username' => 'leo',
                   'friend' =>
                   array (
                         'name' => 'Max Bialystock',
                         'username' => 'max',
                         'friend' =>
                         array (
                               'name' => 'Leo Bloom',
                               'username' => 'leo',
                               'friend' => NULL,
                               'job' => 'Accountant',
                         ),
                          'job' => 'Swindler',
                     ),
                      'job' => 'Accountant',
               )

The print_r() and var_export() functions accept a second argument which, if set to true tells the functions to return the string representation of the variable rather than printing it. To capture the output from var_dump(), however, you need to use output buffering:

             ob_start();
             var_dump($user);
             $dump = ob_get_contents();
             ob_end_clean();

This puts the results of var_dump($user) in $dump.