I'd like to capture the output of var_dump to a string.
The PHP documentation says;
As with anything that outputs its result directly to the browser, the output-control functions can be used to capture the output of this function, and save it in a string (for example).
What would be an example of how that might work?
print_r() isn't a valid possibility, because it's not going to give me the information that I need.
Use output buffering:
<?php
ob_start();
var_dump($someVar);
$result = ob_get_clean();
?>
strip_tags(), this will simply return the type and value. –
Helyn var_export answer is long-winded and irrelevant, since it uses neither var_dump nor output capture, and var_export, like print_r, doesn't give types. –
Selfcentered var_dump documentations recommends capturing the string with output controls. –
Virgenvirgie var_exportYou may want to check out var_export — while it doesn't provide the same output as var_dump it does provide a second $return parameter which will cause it to return its output rather than print it:
$debug = var_export($my_var, true);
I prefer this one-liner to using ob_start and ob_get_clean(). I also find that the output is a little easier to read, since it's just PHP code.
The difference between var_dump and var_export is that var_export returns a "parsable string representation of a variable" while var_dump simply dumps information about a variable. What this means in practice is that var_export gives you valid PHP code (but may not give you quite as much information about the variable, especially if you're working with resources).
$demo = array(
"bool" => false,
"int" => 1,
"float" => 3.14,
"string" => "hello world",
"array" => array(),
"object" => new stdClass(),
"resource" => tmpfile(),
"null" => null,
);
// var_export -- nice, one-liner
$debug_export = var_export($demo, true);
// var_dump
ob_start();
var_dump($demo);
$debug_dump = ob_get_clean();
// print_r -- included for completeness, though not recommended
$debug_printr = print_r($demo, true);
$debug_export in above example): array (
'bool' => false,
'int' => 1,
'float' => 3.1400000000000001,
'string' => 'hello world',
'array' =>
array (
),
'object' =>
stdClass::__set_state(array(
)),
'resource' => NULL, // Note that this resource pointer is now NULL
'null' => NULL,
)
$debug_dump in above example): array(8) {
["bool"]=>
bool(false)
["int"]=>
int(1)
["float"]=>
float(3.14)
["string"]=>
string(11) "hello world"
["array"]=>
array(0) {
}
["object"]=>
object(stdClass)#1 (0) {
}
["resource"]=>
resource(4) of type (stream)
["null"]=>
NULL
}
$debug_printr in above example):Array
(
[bool] =>
[int] => 1
[float] => 3.14
[string] => hello world
[array] => Array
(
)
[object] => stdClass Object
(
)
[resource] => Resource id #4
[null] =>
)
var_export does not handle circular referencesIf you're trying to dump a variable with circular references, calling var_export will result in a PHP warning:
$circular = array();
$circular['self'] =& $circular;
var_export($circular);
Results in:
Warning: var_export does not handle circular references in example.php on line 3
array (
'self' =>
array (
'self' => NULL,
),
)
Both var_dump and print_r, on the other hand, will output the string *RECURSION* when encountering circular references.
int(1) while var_export just prints out 1. –
Laid var_export isn't actually better for debugging because you couldn't do a browser search for (int) or (string)` and etc. It also mangles alot of information into a small space, just try: var_export(''); var_export('\'');. And most importantly, get ready for PHP Fatal error: Nesting level too deep - recursive dependency? in C:\path\file.php on line 75 –
Fraxinella var_dump over print_r because var_dump gives type information, whereas print_r and var_export do not. This answer also muddies the waters by using type names as key names, unintentionally making it look (at least at first glance) as if var_export actually does give type information. IMO this is misleading, doesn't answer OP, and should have <0 votes. –
Selfcentered Use output buffering:
<?php
ob_start();
var_dump($someVar);
$result = ob_get_clean();
?>
strip_tags(), this will simply return the type and value. –
Helyn var_export answer is long-winded and irrelevant, since it uses neither var_dump nor output capture, and var_export, like print_r, doesn't give types. –
Selfcentered var_dump documentations recommends capturing the string with output controls. –
Virgenvirgie You could also do this:
$dump = print_r($variable, true);
print_r where I can, but unfortunately sometimes it doesn't provide enough information. For instance, since it casts to string where it can, both false and null show as an empty string. In cases where I care about the difference between these, I would begrudgingly resort to var_dump or var_export. –
Cyanide if you are using PHP>=7.0.0
function return_var_dump(...$args): string
{
ob_start();
try {
var_dump(...$args);
return ob_get_clean();
} catch (\Throwable $ex) {
// PHP8 ArgumentCountError for 0 arguments, probably..
// in php<8 this was just a warning
ob_end_clean();
throw $ex;
}
}
or if you are using PHP >=5.3.0:
function return_var_dump(){
ob_start();
call_user_func_array('var_dump', func_get_args());
return ob_get_clean();
}
or if you are using PHP<5.3.0 (this function is actually compatible all the way back to PHP4)
function return_var_dump(){
$args = func_get_args(); // For <5.3.0 support ...
ob_start();
call_user_func_array('var_dump', $args);
return ob_get_clean();
}
(prior to 5.3.0 there was a bug with func_get_args if used directly as an argument for another function call, so you had to put it in a variable and use the variable, instead of using it directly as an argument..)
function vardump(...$args){if(count($args)){ob_start();var_dump(...$args);return ob_get_clean();}return '';} –
Lovett function vardump(...$args){if(count($args)){ob_start();var_dump(...$args);return ob_get_clean();}else{trigger_error("vardump() expects at least 1 parameter, 0 given.",E_USER_ERROR);return "";}} - for PHP<8 when you give var_dump() 0 arguments, it triggers an error, so your vardump should do the same when there's 0 arguments. but if you are using PHP>=8 it will throw an ArgumentCountError exception, so your vardump() should also do the same in php>=8.. –
Bromleigh Also echo json_encode($dataobject); might be helpful
json_encode will not contain all the data var_dump does (as variable types for example). json_encode outputs the same information as print_R, inly in different format. –
Easel var_dump. He also stated that print_R is provides insufficient information for his needs. There is no real difference in information that is provided by json_encode and print_r - only the data format is different. Given this, if print_r is insufficient, so is json_encode. Please don't complain about the downvote anymore. It obviously wasn't just random click, so deal with it. –
Easel You may also try to use the serialize() function. Sometimes it is very useful for debugging purposes.
error_log it, you should not use this solution, since serialize's output can contain null bytes and error_log truncates strings containing null bytes. –
Delvecchio This function displays structured information about one or more expressions that includes its type and value.
So, here is the real return version of PHP's var_dump(), which actually accepts a variable-length argument list:
function var_dump_str()
{
$argc = func_num_args();
$argv = func_get_args();
if ($argc > 0) {
ob_start();
call_user_func_array('var_dump', $argv);
$result = ob_get_contents();
ob_end_clean();
return $result;
}
return '';
}
$argc check here is unnecessary and arguably incorrect as pointed out by @hanshenrik, and once you take that away all you're really adding is the call_user_func_array and func_get_args calls. –
Delvecchio If you want to have a look at a variable's contents during runtime, consider using a real debugger like XDebug. That way you don't need to mess up your source code, and you can use a debugger even while normal users visit your application. They won't notice.
Here is the complete solution as a function:
function varDumpToString ($var)
{
ob_start();
var_dump($var);
return ob_get_clean();
}
This maybe a bit off topic.
I was looking for a way to write this kind of information to the Docker log of my PHP-FPM container and came up with the snippet below. I'm sure this can be used by Docker PHP-FPM users.
fwrite(fopen('php://stdout', 'w'), var_export($object, true));
file_put_contents('php://stdout',var_export($object, true),FILE_APPEND); –
Bromleigh I really like var_dump()'s verbose output and wasn't satisfied with var_export()'s or print_r()'s output because it didn't give as much information (e.g. data type missing, length missing).
To write secure and predictable code, sometimes it's useful to differentiate between an empty string and a null. Or between a 1 and a true. Or between a null and a false. So I want my data type in the output.
Although helpful, I didn't find a clean and simple solution in the existing responses to convert the colored output of var_dump() to a human-readable output into a string without the html tags and including all the details from var_dump().
Note that if you have a colored var_dump(), it means that you have Xdebug installed which overrides php's default var_dump() to add html colors.
For that reason, I created this slight variation giving exactly what I need:
function dbg_var_dump($var)
{
ob_start();
var_dump($var);
$result = ob_get_clean();
return strip_tags(strtr($result, ['=>' => '=>']));
}
Returns the below nice string:
array (size=6)
'functioncall' => string 'add-time-property' (length=17)
'listingid' => string '57' (length=2)
'weekday' => string '0' (length=1)
'starttime' => string '00:00' (length=5)
'endtime' => string '00:00' (length=5)
'price' => string '' (length=0)
Hope it helps someone.
To get around the print_r shortfall, (returns a 1/0 for true/false), here's a routine to convert true/false to "var_dump" type text before sending the variable to print_r:
$arr=['name'=>'Joe','male'=>true];
$arr1=array_map(function($v){
if(is_bool($v)){
$v='bool('.($v?'true':'false').')';
}
return $v;
}, $arr);
$out = print_r($arr1,true);
echo $out;
From http://htmlexplorer.com/2015/01/assign-output-var_dump-print_r-php-variable.html:
var_dump and print_r functions can only output directly to browser. So the output of these functions can only retrieved by using output control functions of php. Below method may be useful to save the output.
function assignVarDumpValueToString($object) { ob_start(); var_dump($object); $result = ob_get_clean(); return $result; }
ob_get_clean() can only clear last data entered to internal buffer. So ob_get_contents method will be useful if you have multiple entries.
From the same source as above:
function varDumpToErrorLog( $var=null ){ ob_start(); // start reading the internal buffer var_dump( $var); $grabbed_information = ob_get_contents(); // assigning the internal buffer contents to variable ob_end_clean(); // clearing the internal buffer. error_log( $grabbed_information); // saving the information to error_log }
Long string: Just use echo($var); instead of dump($var);.
Object or Array: var_dump('<pre>'.json_encode($var).'</pre>);'
© 2022 - 2024 — McMap. All rights reserved.