Un'alternativa Var_dump più carina / istruttiva in PHP? [chiuso]


130

Ogni programmatore PHP decente ha un print_ro un var_dumpwrapper che usa, ama e assegna tasti di scelta rapida, perché non condividiamo i nostri preferiti .


39
uso solo echo '<pre>'; print_r ($ var); esci; non lo chiudo nemmeno. Immagino di non essere decente
Funky Dude,

Ho modificato il link per indicare github, dove continuo lo sviluppo di Kint, e se hai ancora problemi con esso, per favore fatemelo sapere con qualsiasi mezzo.
Raveren,

1
Ehi, Kint è fantastico! Mi ha appena salvato la giornata.
István Ujj-Mészáros,

2
Perché una domanda che è al 100% un avviso pubblicitario di un programma è in una versione "Faccio il mio var_dump ()" ?? La prima domanda sarebbe perché una pubblicità di prodotto è consentita come domanda.
m3nda,

11
Perché ho realizzato lo strumento più di un anno dopo aver fatto la domanda. Non so cosa ti dia fastidio, ho creato uno strumento open source maturo 10k + line e lo sto migliorando costantemente anni dopo. Ho fornito la mia risposta alla domanda, come è tradizione nella SO.
Raveren,

Risposte:


71

Un anno intero di tempo e lavoro dopo averlo chiesto, ho finalmente aperto la mia versione di var_dump, Kint. Leggi a riguardo nella pagina del progetto o direttamente in github .

Ecco uno screenshot:

Kint

Ci scusiamo per la spina :)


EDIT: Vorrei solo ricordare ai commentatori che questo non è un forum di supporto, se hai problemi / desideri una funzione, ti preghiamo di presentare un problema . Il supporto per la richiesta di commenti verrà contrassegnato per l'eliminazione.


ho dovuto cambiare la dimensione del carattere e abbellire il codice CSS, ma un buon lavoro, mi piace ... proveniente da molto tempo utente
Krumo

1
quali modifiche hai apportato, se credi che sia un miglioramento, puoi inviarmi le modifiche a raveren@gmail.com
raveren il

ero abituato a Krumo e volevo caratteri più piccoli, e ho anche abbellito il codice CSS. Nulla che possa essere definito un vero miglioramento, più come una vecchia abitudine :)
Quamis,

bene l'idea era che il CSS doveva essere compresso insieme al js in modo da interferire il meno possibile con l'output effettivo. Certo, era prevista anche una bella rientranza della fonte generata, ma al momento non ho tempo da dedicare a Kint ..
raveren,

2
Proprio come un esempio, Kint mostra variabili protette e private se scarichi un oggetto, krumo no (perché solo il primo usa le classi di riflessione che presumo). In generale, ho trovato Kint superiore; anche se ho anche dovuto modificare il CSS per renderlo più utilizzabile (quel font enorme non funziona molto bene quando si scaricano tonnellate di proprietà annidate). Oh, e il codice dietro non è un casino, qualcosa che non si può dire di Krumo (scusate l'autore di Krumo!)
Mahn

45

Il mio preferito è la var_dumpfunzione, come fornita dall'estensione Xdebug : basta installare l'estensione (facile, sia su Windows che Linux) , e var_dumpottenere un output migliore:

  • migliore formulazione
    • HTML
    • colori
  • e hai opzioni per mettere a punto quante informazioni dovrebbero essere visualizzate

E uno screenshot veloce:

xdebug


E, naturalmente, Xdebug porta un sacco di altre cose utili, come il debug remoto (ad esempio il debug grafico dell'applicazione PHP, ad esempio in Eclipse PDT) , la profilazione, ...


1
Devo usare questa classe di formattazione xdebug in un host condiviso. C'è un modo per includerlo nel mio progetto personale?
Anyul Rivas,

1
Se non sei amministratore (root) del tuo server, molto probabilmente non sarai in grado di installare un'estensione PHP (non ho mai visto un servizio di hosting condiviso che ne installerebbe uno per installare estensioni PHP) ; quindi no, non sarai in grado di usare Xdebug (comunque, installarlo su un server di produzione non è generalmente una buona idea: è un'estensione di debug, dopotutto) ; dovrai ricorrere a un'implementazione basata su PHP di una funzione di emissione variabile (vedi alcune altre risposte)
Pascal MARTIN

1
sì, avevo solo bisogno della classe per inviarmi un po 'di output quando si verifica un errore.
Anyul Rivas,

34

Ho scritto il mio: REF ( demo ):

r () output

I piani sono di aggiungere il rendering di solo testo e visualizzare informazioni sull'espressione di input come fa Kint ...


4
Ottimo lavoro, ottimo strumento
ssuperczynski

2
REF è fantastico, colorato, veloce. Io lo uso per tutto il tempo.
Marty McGee,

2
Ottimo strumento, ci sono appena passato. Grazie!
Andris,

Alcune persone usano il compositore, beh ... non io. Se si desidera creare un dlluserò questo "debug". Grazie e bel lavoro!
Alex,

27

Ecco il mio, che uso in linea, molto utile:

$pretty = function($v='',$c="&nbsp;&nbsp;&nbsp;&nbsp;",$in=-1,$k=null)use(&$pretty){$r='';if(in_array(gettype($v),array('object','array'))){$r.=($in!=-1?str_repeat($c,$in):'').(is_null($k)?'':"$k: ").'<br>';foreach($v as $sk=>$vl){$r.=$pretty($vl,$c,$in+1,$sk).'<br>';}}else{$r.=($in!=-1?str_repeat($c,$in):'').(is_null($k)?'':"$k: ").(is_null($v)?'&lt;NULL&gt;':"<strong>$v</strong>");}return$r;};

echo $pretty($some_variable);

2
Adoro questa funzione - facile e chiara e ho già parlato molto facilmente :)
derekdreery il

Grazie. Io lo uso per tutto il tempo. Dovrebbe essere integrato in PHP davvero. Puoi inserire la tua formattazione usando il secondo parametro. ad esempio echo $ pretty ($ some_variable, "-");
Guillermo Phillips,

7
Questo combina magnificamente tutte le peggiori funzionalità di print_r, var_dump e var_export. Nessun escape HTML, accetta solo un singolo parametro, si blocca sulla ricorsione, non può restituire l'output e, per finire, è totalmente illeggibile . Non voglio essere uno stronzo, ma i commenti lo fanno sembrare così perfetto.
Raveren,

Grazie per il tuo commento @Raveren. Se potessi essere più specifico, migliorerò la mia risposta.
Guillermo Phillips,

2
IMO la migliore soluzione a linea singola è semplicemente function pretty(){echo'<pre>';foreach(func_get_args()as $arg){ob_start();var_dump($arg);echo htmlentities(ob_get_clean())."\n#####\n#####\n\n";}die;}. Var_dump è una funzione molto dettagliata, gestisce tutti i casi limite di PHP (di cui ci sono LOTTI) ed è stabile al 100%, anche se non così leggibile. Ma alla fine, se trovi che la tua implementazione è la migliore per te, è quello che dovresti assolutamente usare.
Raveren,

16

Stai cercando Krumo ( Attenzione, avvisi di Chrome per malware ).

Per dirla semplicemente, Krumo è un sostituto di print_r () e var_dump (). Per definizione Krumo è uno strumento di debug (inizialmente per PHP4 / PHP5, ora solo per PHP5), che visualizza informazioni strutturate su qualsiasi variabile PHP.


È brillante! Grazie. +1
the_drow il

2
quando l'ho provato, è stato rotto. L'ho segnalato, ma nessuna risposta e nessuna nuova versione
Mawg dice di ripristinare Monica il

2
@Pekka Il link sta generando un avviso malware in Chrome.
Tim Post

Oggi krumo è stato aggiornato da questo ragazzo github.com/mmucklo/krumo (ma Kint potrebbe essere migliore, maggiori dettagli)
lolesque

9

Adoro Firephp plus firebug

  • Scrive le informazioni di registrazione utilizzando le intestazioni, quindi non interrompe AJAX.
  • Ti dà una rappresentazione grafica molto bella delle variabili / oggetti che registri
  • Può visualizzare il nome del file e il numero di riga in cui si verifica ogni istruzione di registro
  • Facile da usare nel progetto, con un'API procedurale o orientata agli oggetti


8

La mia soluzione (parziale) per questo è semplicemente aggiungere una funzione come questa (usando Google Chrome):

<?
function console_dump($value)
{ 
?>
<script>
    console.log(<? echo json_encode($value); ?>);
</script>
<?
}
?>

Premi Ctrl + Maiusc + J (apre la console) e qui puoi trovare la struttura JSON. Ancora più utile per una bella stampa delle risposte del corso JSON.


8

Un esempio completo di ciò che uso ...

<pre>

<?php


//*********** Set up some sample data

$obj = new stdClass;
$obj->a=123;
$obj->pl=44;
$obj->l=array(31,32);

$options = array(
  'Orchestra'=>array(1=>'Strings', 8=>'Brass', 9=>$obj, 3=>'Woodwind', 16=>'Percussion'),
  2=>'Car',
  4=>'Bus',
  'TV'=>array(21=>'Only Fools', 215=>'Brass Eye', 23=>'Vic Bob',44=>null, 89=>false));


//*********** Define the function

function dump($data, $indent=0) {
  $retval = '';
  $prefix=\str_repeat(' |  ', $indent);
  if (\is_numeric($data)) $retval.= "Number: $data";
  elseif (\is_string($data)) $retval.= "String: '$data'";
  elseif (\is_null($data)) $retval.= "NULL";
  elseif ($data===true) $retval.= "TRUE";
  elseif ($data===false) $retval.= "FALSE";
  elseif (is_array($data)) {
    $retval.= "Array (".count($data).')';
    $indent++;
    foreach($data AS $key => $value) {
      $retval.= "\n$prefix [$key] = ";
      $retval.= dump($value, $indent);
    }
  }
  elseif (is_object($data)) {
    $retval.= "Object (".get_class($data).")";
    $indent++;
    foreach($data AS $key => $value) {
      $retval.= "\n$prefix $key -> ";
      $retval.= dump($value, $indent);
    }
  }
  return $retval;
}


//*********** Dump the data

echo dump($options);

?>
</pre>

Uscite ...

Array (4)
 [Orchestra] = Array (5)
 |   [1] = String: 'Strings'
 |   [8] = String: 'Brass'
 |   [9] = Object (stdClass)
 |   |   a -> Number: 123
 |   |   pl -> Number: 44
 |   |   l -> Array (2)
 |   |   |   [0] = Number: 31
 |   |   |   [1] = Number: 32
 |   [3] = String: 'Woodwind'
 |   [16] = String: 'Percussion'
 [2] = String: 'Car'
 [4] = String: 'Bus'
 [TV] = Array (5)
 |   [21] = String: 'Only Fools'
 |   [215] = String: 'Brass Eye'
 |   [23] = String: 'Vic Bob'
 |   [44] = NULL
 |   [89] = FALSE

1
Ho cambiato \ n in PHP_EOL e questo funziona bene quando si usa php dal CMD di
windows

7

Ecco il mio:

class sbwDebug
{
    public static function varToHtml($var = '', $key = '')
    {
        $type = gettype($var);
        $result = '';

        if (in_array($type, ['object', 'array'])) {
            $result .= '
        <table class="debug-table">
            <tr>
            <td class="debug-key-cell"><b>' . $key . '</b><br/>Type: ' . $type . '<br/>Length: ' . count($var) . '</td>
            <td class="debug-value-cell">';

            foreach ($var as $akey => $val) {
                $result .= sbwDebug::varToHtml($val, $akey);
            }
            $result .= '</td></tr></table>';
        } else {
            $result .= '<div class="debug-item"><span class="debug-label">' . $key . ' (' . $type . '): </span><span class="debug-value">' . $var . '</span></div>';
        }

        return $result;
    }
}

In stile con:

table.debug-table {
  padding: 0;
  margin: 0;
  font-family: arial,tahoma,helvetica,sans-serif;
  font-size: 11px;
}

td.debug-key-cell {
  vertical-align: top;
  padding: 3px;
  border: 1px solid #AAAAAA;
}

td.debug-value-cell {
  vertical-align: top;
  padding: 3px;
  border: 1px solid #AAAAAA;
}

div.debug-item {
  border-bottom: 1px dotted #AAAAAA;
}

span.debug-label {
  font-weight: bold;
}

2
Non male in realtà. Probabilmente sarebbe stato votato di più se avessi mostrato un esempio dell'output.
Mawg dice di ripristinare Monica il

@acSlater Funziona per me, devi solo creare la sbwDebugclasse che ha dimenticato di pubblicare e inserirvi la funzione.
Dennis98,

6

Di recente ho sviluppato un'estensione di Chrome gratuita (lavori in corso) per abbellire i miei dump var senza librerie, senza pre tag e senza installazione per ogni singola app. Tutto fatto con JavaScript e regEx. Tutto quello che devi fare è installare l'estensione e sei pronto per partire. Sto lavorando anche su una versione di Firefox. Ecco la pagina di GitHub. Spero di averlo presto disponibile sui webstore di Chrome e Firefox!

https://github.com/alexnaspo/var_dumpling

Ecco un esempio di output:

Esempio di output


6
bello amico! appena scaricato l'estensione e funziona perfettamente! Grazie!
coryj,

5
Amico ... grazie. Sono stato alla ricerca di qualcosa di simile per un po '
Broadbent

1
Irreale. La migliore opzione ancora!
Christian

Provato con Firefox 15, diceva che non era compatibile. Qualche possibilità di aggirare questo?
cyberfly

1
È bellissimo, vorrei averlo trovato prima!


2

Quelle librerie fantasiose sono fantastiche ... tranne le spese generali. Se vuoi un var_dump semplice e carino che accetta infiniti parametri, prova la mia funzione. Aggiunge un po 'di HTML semplice. Vengono aggiunti anche gli attributi dei dati, se si utilizza HTML5, le versioni inferiori li ignoreranno, ma facilita l'apertura dell'elemento nella console del browser e ottiene un po 'più di informazioni se ciò che vedi sullo schermo non è sufficiente.

Il layout è molto semplice, senza spese generali. Fornisce una tonnellata di informazioni per ogni parametro tra cui cose come gettypee persino il classnome per i dump di oggetti (incluso XML). È provato e vero, lo uso da anni.

function preDump() {    //  use string "noEcho" to just get a string return only
    $args = func_get_args();
    $doEcho = TRUE; $sb;
    if ($args) {
        $sb = '<div style="margin: 1em 0;"><fieldset style="display:inline-block;padding:0em 3em 1em 1em;"><legend><b>preDump: '.count($args).' Parameters Found.</b></legend>';
        foreach (func_get_args() as $arg) {
            if (gettype($arg) == 'string') if ($arg == 'noEcho') { $doEcho = FALSE; $sb = preg_replace('/(preDump: )[0-9]+/', 'preDump: '.(count($args)-1), $sb); continue; }
            $sb .= '<pre data-type="'.gettype($arg).'"';
            switch (gettype($arg)) {
                case "boolean":
                case "integer":
                    $sb .= ' data-dump="json_encode"><p style="border-bottom:1px solid;margin:0;padding:0 0 0 1em;"><b>gettype('.gettype($arg).')</b></p><p>';
                    $sb .= json_encode($arg);
                    break;
                case "string":
                    $sb .= ' data-dump="echo"><p style="border-bottom:1px solid;margin:0;padding:0 0 0 1em;"><b>gettype('.gettype($arg).')</b></p><p>';
                    $sb .= $arg;
                    break;
                default:
                    $sb .= ' data-dump="var_dump"';
                    if (is_object($arg)) $sb .= 'data-class="'.get_class($arg).'"';
                    $sb .= '><p style="border-bottom:1px solid;margin:0;padding:0 0 0 1em;"><b>gettype('.gettype($arg).')';
                    if (is_object($arg)) $sb .= ' ['.get_class($arg).']';
                    $sb .= '</b></p><p>';
                    ob_start();
                    var_dump($arg);
                    $sb .= ob_get_clean();
                    if (ob_get_length()) ob_end_clean();
            }
            $sb .= '</p></pre>';
        }
        $sb .= '</fieldset></div>';
    }
    else {
        $sb = '<div style="margin: 1em 0;"><fieldset style="display:inline-block;"><legend><b>preDump: [ERROR]</b></legend><h3>No Parameters Found</h3></fieldset></div>';
    }
    if ($doEcho) echo($sb);
    return $sb;
}

E se usi Codeigniter, aggiungi anche il tuo CI ESTREMAMENTE SEMPLICEMENTE. Innanzitutto, vai a application/config/autoload.phpe assicurati che helper 'string'sia attivo.

$autoload['helper'] = array( 'string' ); 

Poi basta andare creare un file denominato MY_string_helper.phpin application/helperse semplice inserire la funzione in una tipica ifdichiarazione per il controllo dell'esistenza.

<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
    if (!function_exists('preDump')) {
        function preDump() {
            ...
        }
    }
//  DON'T CLOSE PHP

| OPPURE |, se vuoi prendere una direzione diversa.

Il frammento seguente è uguale a quello sopra, tranne che mostrerà le variabili nella console del browser. Questo a volte può semplificare il debug delle chiamate agli oggetti sql e di altre chiamate di array e oggetti in cui manca il nome della chiave o altro.

function consoleDump() {    //  use string "noEcho" to just get a string return only
    $args = func_get_args();
    $doEcho = TRUE; $sb;
    if ($args) {
        $sb = '<script type="text/javascript">console.log("<" + new Array('.(count($args) < 10 ? '49': '48').').join("-") + "[consoleDump: '.count($args).' items]" + new Array(50).join("-") + ">"); console.log([';

        foreach (func_get_args() as $i => $arg) {
            if (gettype($arg) == 'string') if ($arg == 'noEcho') { $doEcho = FALSE; $sb = preg_replace('/(consoleDump: )[0-9]+/', 'consoleDump: '.(count($args)-1), $sb); continue; }
            $sb .= '{ "type": "'.gettype($arg).'", ';
            switch (gettype($arg)) {
                case "boolean":
                case "integer":
                case "string":
                    $sb .= '"value": '.json_encode($arg);
                    break;
                default:
                    $sb .= '"value": '.json_encode($arg);
                    if (is_object($arg) || is_array($arg)) $sb .= ', "count": '.json_encode(count((array)$arg));
                    if (is_object($arg)) $sb .= ', "objectClass": "'.get_class($arg).'"';
            }
            $sb .= '}';
            if ($i < count($args)-1) $sb .= ', ';
        }
        $sb .= ']); console.log("<" + new Array(120).join("-") + ">"); </script>';
    }
    else {
        $sb = '<script type="text/javascript">console.log("<" + new Array(120).join("-") + ">");console.log("consoleDump: [ERROR] No Parameters Found");console.log("<" + new Array(120).join("-") + ">");</script>';
    }
    if ($doEcho) echo($sb);
    return $sb;
}

Funziona con tutto!

consoleDump($simpXMLvar, $_SESSION, TRUE, NULL, array( 'one' => 'bob', 'two' => 'bill' ), (object)array( 'one' => 'bob', 'two' => 'bill' ));


<------------------------------------------------[consoleDump: 6 items]------------------------------------------------->
[Object, Object, Object, Object, Object, Object] 
// This drops down to show your variables in JS objects, like:
    0: Object
        count: 4
        objectClass: "SimpleXMLElement"
        type: "object"
        value: Object
        __proto__: Object
        // ...etc...
<-----------------------------------------------------------------------------------------------------------------------> 

1
Perché doversi preoccupare di riduzioni trascurabili delle prestazioni in uno strumento di sviluppo? Questa funzione è letteralmente echo '<pre>';var_dump($var);echo '</pre>';più un po 'di testo a valore zero.
Raveren,

@Raveren yea tranne preDump('value', TRUE, array( 'bob => 'bill' ), (object)array( 'bob => 'bill' )' is quick and easy and gives a nice layout visually in the browser that shows each variable passed in it's own "area" with a type label, thus making debugging quick and easy. And since it's a snippet i keep in my IDE's toolbox, i can recall it with ease on any needed page or while working with any library. But sure, it's just an echo 'pre'; var_dump` con alcuni simple htmlattorno ad esso, non testo che aggiunge valore 0. lol kik. Se non ti piace, non usarlo. Solo un suggerimento.
SpYk3HH,

@Raveren E se ti è piaciuto ... adorerai davvero il mio aggiornamento: P
SpYk3HH,


1

Ancora un'altra versione cresciuta in casa:

http://github.com/perchten/neat_html

Mi piace pensare che sia piuttosto flessibile. Non mira a un particolare ambiente di output ma ha una serie di argomenti opzionali che è possibile specificare perché modificare l'output / stampa o il comportamento, nonché alcune impostazioni persistenti.




1

Se hai a che fare con array molto grandi in PHP, questa funzione può aiutare:

function recursive_print ($varname, $varval) {
  if (! is_array($varval)):
    print $varname . ' = ' . var_export($varval, true) . ";<br>\n";
  else:
    print $varname . " = array();<br>\n";
    foreach ($varval as $key => $val):
      recursive_print ($varname . "[" . var_export($key, true) . "]", $val);
    endforeach;
  endif;
}

Fondamentalmente scarica l'intero array in cui ogni elemento si trova in una riga separata, il che è utile per trovare i giusti percorsi completi per determinati elementi.

Esempio di output:

$a = array();
$a[0] = 1;
$a[1] = 2;
$a[2] = array();
$a[2][0] = 'a';
$a[2][1] = 'b';
$a[2][2] = 'c';

Vedi: Come esportare l'array PHP in cui ogni coppia chiave-valore si trova in una riga separata?


1

Sono sorpreso che nessuno abbia menzionato il codice più semplice (anche se non molto carino). Se vuoi solo ottenere un risultato leggibile (senza colori o indentazione), un semplice <pre>intorno a var_dumpun'opera, come in:

echo "<pre>";
var_dump($myvariable);
echo "</pre>";

Non riesco a ottenere un sovraccarico molto più basso di questo!



0

Il mio preferito è il debug da https://github.com/hazardland/debug.php che è una libreria che contiene solo una singola funzione chiamata debug (puoi semplicemente copiare quella funzione nel tuo progetto o nella tua libreria) . L' output tipico di debug () html è simile al seguente:

inserisci qui la descrizione dell'immagine

Ma puoi generare dati come un semplice testo con la stessa funzione anche (con 4 schede rientrate nello spazio) come questo (e persino registrarlo nel file se necessario):

string : "Test string"
boolean : true
integer : 17
float : 9.99
array (array)
    bob : "alice"
    1 : 5
    2 : 1.4
object (test2)
    another (test3)
        string1 : "3d level"
        string2 : "123"
        complicated (test4)
            enough : "Level 4"

0

TVarDumper

Questo è un ottimo strumento che ha lo scopo di sostituire la funzione buggy PHP var_dumpeprint_r , poiché può identificare correttamente gli oggetti a cui fa riferimento ricorsivamente in una struttura ad oggetti complessa. Ha anche un controllo di profondità ricorsivo per evitare la visualizzazione ricorsiva indefinita di alcune variabili peculiari.

Vedi: TVarDumper.php.


Per altre soluzioni alternative che fornisce più vantaggi sopra var_dumped print_re in grado di supportare i riferimenti circolari, verificate: Uso print_r e var_dump con riferimento circolare .


Per ulteriori idee, controlla anche: Come esegui il debug degli script PHP?


0

Il mio è più semplice, per me non ho molta conoscenza / tempo per cambiare infrastruttura installare xdebug, ecc. Ecc.

E in altri casi, ad esempio, non è necessario molto per un semplice sito Web WP

Quindi io uso:

highlight_string("\n<?" . var_export($var, true) . "?>\n");

mi aiuta davvero molto.

ma poiché preferisco DevConsole Environment utilizzo questa fantastica ma semplice funzione:

https://codeinphp.github.io/post/outputting-php-to-browser-console/

Piccola modifica:

<?php 

/**
 * Logs messages/variables/data to browser console from within php
 *
 * @param $name: message to be shown for optional data/vars
 * @param $data: variable (scalar/mixed) arrays/objects, etc to be logged
 * @param $jsEval: whether to apply JS eval() to arrays/objects
 *
 * @return none
 * @author Sarfraz
 */
function logConsole($name, $data = NULL, $jsEval = FALSE)
{
     if (! $name) return false;

     $isevaled = false;
     $type = ($data || gettype($data)) ? 'Type: ' . gettype($data) : '';

     if ($jsEval && (is_array($data) || is_object($data)))
     {
          $data = 'eval(' . preg_replace('#[\s\r\n\t\0\x0B]+#', '', json_encode($data)) . ')';
          $isevaled = true;
     }
     else
     {
          $data = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
     }

     # sanitalize
     $data = $data ? $data : '';
     $search_array = array("#'#", '#""#', "#''#", "#\n#", "#\r\n#");
     $replace_array = array('"', '', '', '\\n', '\\n');
     $data = preg_replace($search_array,  $replace_array, $data);
     $data = ltrim(rtrim($data, '"'), '"');
     $data = $isevaled ? $data : ($data[0] === "'") ? $data : "'" . $data . "'";

$js = <<<JSCODE
\n<script>
// fallback - to deal with IE (or browsers that don't have console)
if (! window.console) console = {};
console.log = console.log || function(name, data){};
// end of fallback

console.log('===== PHP Dump =====');
console.log('$name');
console.log('$type');
console.log($data);
console.log('===== / PHP Dump =====');
console.log('\\n');
</script>
JSCODE;

     echo $js;
} # end logConsole

0

Un'altra opzione è quella di

composer require symfony/var-dumper --save-dev

Quindi nel tuo file usi solo dump($var) e finirai con un output come questoinserisci qui la descrizione dell'immagine


0

Ho dovuto aggiungere un'altra risposta qui perché non volevo davvero seguire i passaggi delle altre soluzioni. È estremamente semplice e non richiede estensioni, include ecc. Ed è ciò che preferisco. È molto facile e molto veloce.

Prima basta json_encode la variabile in questione:

echo json_encode($theResult);

Copia il risultato che ottieni nell'editor JSON su http://jsoneditoronline.org/ semplicemente copialo nel riquadro di sinistra, fai clic su Copia> e stampa in modo carino il JSON in un formato ad albero davvero carino.

A ciascuno il suo, ma si spera che questo aiuti alcuni altri ad avere un'altra bella opzione! :)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.