php \n - Come posso catturare il risultato di var_dump su una stringa?





print_r object (10)


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

Le funzioni var_dump e print_r possono essere inviate direttamente al browser. Quindi l'output di queste funzioni può essere recuperato solo utilizzando le funzioni di controllo dell'output di php. Sotto il metodo 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 immessi 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
}

Mi piacerebbe catturare l'output di var_dump su una stringa.

I documenti PHP dicono;

Come per tutto ciò che produce il risultato direttamente nel browser, le funzioni di controllo dell'output possono essere utilizzate per acquisire l'output di questa funzione e salvarlo in una stringa (ad esempio).

Qualcuno può darmi un esempio di come potrebbe funzionare?

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




Puoi anche fare questo:

$dump = print_r($variable, true);



ecco la soluzione completa come funzione.

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



Sono consapevole che questa domanda è vecchia, ma nessuno ha menzionato questo punto.

Dal manuale PHP :

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

Quindi, ecco la vera versione di ritorno di var_dump() di PHP, 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 '';
}

Saluti.




Anche echo json_encode($dataobject); potrebbe essere utile




Se vuoi dare un'occhiata ai contenuti delle variabili durante il runtime, considera l'uso di un debugger reale come XDebug. In questo modo non hai bisogno di rovinare il tuo codice sorgente e puoi usare un debugger anche mentre i normali utenti visitano la tua applicazione. Non se ne accorgeranno.




Prova var_export

Puoi provare var_export - anche se non fornisce lo stesso output di var_dump , fornisce un secondo parametro $return che farà sì che restituisca l'output piuttosto che stamparlo:

$debug = var_export($my_var, true);

Perché?

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

La differenza tra var_dump e var_export è che var_export restituisce una "rappresentazione di stringa parsable di una variabile" mentre var_dump semplicemente scarica informazioni su una variabile. Ciò significa in pratica che var_export ti fornisce un codice PHP valido (ma potrebbe non fornirti altrettante informazioni sulla variabile, specialmente se stai lavorando con le resources ).

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 di output:

var_export ( $debug_export nell'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_dump nell'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_printr nell'esempio sopra):

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

    [object] => stdClass Object
        (
        )

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

var_export : var_export non gestisce riferimenti circolari

Se stai provando a scaricare una variabile con riferimenti circolari, chiamando var_export verrà visualizzato 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,
   ),
 )

Sia var_dump che print_r , d'altra parte, *RECURSION* la stringa *RECURSION* quando incontrano riferimenti circolari.




Puoi anche provare a utilizzare la funzione serialize() , a volte è molto utile per il debug delle puproves.




function return_var_dump(){
    //works like var_dump, but 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();
}



Se stavi cercando un'alternativa per scrivere il brutto controllo -1, preferisci invece una ~ tilde.

if (~haystack.indexOf('needle')) alert('found');

Joe Zimmerman - vedrai che usando ~ on -1 lo converte a 0. Il numero 0 è un valore falso, il che significa che verrà valutato come falso quando convertito in booleano. Potrebbe non sembrare una grande intuizione all'inizio, ma ricorda che funzioni come indexOf restituiscono -1 quando la query non viene trovata. Ciò significa che invece di scrivere qualcosa di simile a questo:

if (someStr.indexOf("a") >= 0) {
  // Found it
} else  {
  // Not Found
}

Ora puoi avere un minor numero di caratteri nel codice in modo da poterlo scrivere in questo modo:

if (~someStr.indexOf("a")) {
  // Found it
} else  {
  // Not Found
}

Maggiori dettagli qui





php string var-dump