Vorrei catturare l'output di var_dump una stringa.

La documentazione di PHP dice;

Come per qualsiasi cosa che trasmetta il suo risultato direttamente al browser, le funzioni di controllo dell'output possono essere utilizzate per catturare l'output di questa funzione e salvarlo in una stringa (ad esempio).

Quale sarebbe un esempio di come potrebbe funzionare?

print_r() non è una possibilità valida, perché non mi darà le informazioni di cui ho bisogno.

Usa buffer di output:

<?php
ob_start();
var_dump($someVar);
$result = ob_get_clean();
?>

Provare var_export

Potresti voler dare un'occhiata var_export- sebbene non fornisca lo stesso output in var_dumpquanto fornisce un secondo $returnparametro che gli farà restituire il suo output piuttosto che stamparlo:

$debug = var_export($my_var, true);

Perché?

Preferisco questo one-liner all'utilizzo di ob_starteob_get_clean() . Trovo anche che l'output sia un po 'più facile da leggere, dal momento che è solo un codice PHP.

La differenza tra var_dumpe var_exportè che var_exportrestituisce una "rappresentazione di stringa analizzabile di una variabile" mentre var_dumpscarica semplicemente informazioni su una variabile. Ciò che ciò significa in pratica è che var_exportti fornisce un codice PHP valido (ma potrebbe non fornirti altrettante informazioni sulla variabile, specialmente se stai lavorando con risorse ).

demo:

$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);

La differenza nell'output:

var_export ( $debug_exportnell'esempio sopra):

 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,
)

var_dump ( $debug_dumpnell'esempio sopra):

 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
}

print_r ( $debug_printrnell'esempio sopra):

Array
(
    [bool] => 
    [int] => 1
    [float] => 3.14
    [string] => hello world
    [array] => Array
        (
        )

    [object] => stdClass Object
        (
        )

    [resource] => Resource id #4
    [null] => 
)

Avvertenza: var_exportnon gestisce riferimenti circolari

Se stai cercando di scaricare una variabile con riferimenti circolari, la chiamata var_exportcomporterà un avviso PHP:

 $circular = array();
 $circular['self'] =& $circular;
 var_export($circular);

Risultati in:

 Warning: var_export does not handle circular references in example.php on line 3
 array (
   'self' => 
   array (
     'self' => NULL,
   ),
 )

Entrambi var_dumpe print_r, d'altra parte, produrranno la stringa *RECURSION*quando incontreranno riferimenti circolari.

Puoi anche fare questo:

$dump = print_r($variable, true);

Puoi anche provare a usare il serialize() funzione. A volte è molto utile per scopi di debug.

function return_var_dump(){
    // It works like var_dump, but it returns a string instead of printing it.
    $args = func_get_args(); // For <5.3.0 support ...
    ob_start();
    call_user_func_array('var_dump', $args);
    return ob_get_clean();
}

Inoltre echo json_encode($dataobject);potrebbe essere utile

Dal manuale di PHP :

Questa funzione visualizza informazioni strutturate su una o più espressioni che ne includono il tipo e il valore.

Quindi, ecco la vera versione di ritorno di PHP var_dump(), che in realtà accetta un elenco di argomenti di lunghezza variabile:

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 '';
}

Se vuoi dare un'occhiata al contenuto di una variabile durante il runtime, considera l'utilizzo di un vero debugger come XDebug. In questo modo non è necessario incasinare il codice sorgente e utilizzare un debugger anche quando gli utenti normali visitano l'applicazione. Non se ne accorgeranno.

Ecco la soluzione completa come funzione:

function varDumpToString ($var)
{
    ob_start();
    var_dump($var);
    return ob_get_clean();
}

Questo forse è un po 'fuori tema.

Stavo cercando un modo per scrivere questo tipo di informazioni nel registro Docker del mio contenitore PHP-FPM e ho trovato lo snippet di seguito. Sono sicuro che questo può essere utilizzato dagli utenti Docker PHP-FPM.

fwrite(fopen('php://stdout', 'w'), var_export($object, true));

Mi piace molto l' var_dump()output dettagliato e non sono soddisfatto dell'output di var_export()'o print_r()' perché non ha fornito quante più informazioni (ad es. Tipo di dati mancante, lunghezza mancante).

Per scrivere codice sicuro e prevedibile, a volte è utile distinguere tra una stringa vuota e una null. O tra un 1 e un vero. O tra un null e un falso. Quindi voglio il mio tipo di dati nell'output.

Sebbene utile, non ho trovato una soluzione pulita e semplice nelle risposte esistenti per convertire l'output colorato di var_dump()un output leggibile dall'uomo in una stringa senza i tag html e includendo tutti i dettagli davar_dump() .

Nota che se hai un colore var_dump(), significa che hai installato Xdebug che sovrascrive il valore predefinito di php var_dump()per aggiungere colori html.

Per questo motivo, ho creato questa leggera variazione dando esattamente ciò di cui ho bisogno:

function dbg_var_dump($var)
    {
        ob_start();
        var_dump($var);
        $result = ob_get_clean();
        return strip_tags(strtr($result, ['=>' => '=>']));
    }

Restituisce la seguente stringa piacevole:

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)

Spero che aiuti qualcuno.

Da http://htmlexplorer.com/2015/01/assign-output-var_dump-print_r-php-variable.html :

Le funzioni var_dump e print_r possono essere emesse solo direttamente nel browser. Quindi l'output di queste funzioni può essere recuperato solo usando le funzioni di controllo dell'output di php. Il metodo seguente può essere utile per salvare l'output.

function assignVarDumpValueToString($object) {
    ob_start();
    var_dump($object);
    $result = ob_get_clean();
    return $result;
}

ob_get_clean () può cancellare solo gli ultimi dati inseriti nel buffer interno. Quindi il metodo ob_get_contents sarà utile se hai più voci.

Dalla stessa fonte di cui sopra:

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
}

Stringa lunga : basta usare echo($var);invece di dump($var);.

Oggetto o matrice :var_dump('<pre>'.json_encode($var).'</pre>);'