Uma alternativa Var_dump mais bonita / informativa em PHP? [fechadas]

Todo programador decente de PHP tem print_rou var_dumpinvólucro que usa, ama e atribui teclas de atalho, por que não compartilhamos as nossas favoritas ?

Um ano inteiro de tempo e trabalho depois de perguntar isso, finalmente abri minha versão do var_dump, Kint. Leia sobre isso na página do projeto ou diretamente no github .

Aqui está uma captura de tela:

Desculpe pelo plugue :)

EDIT: Gostaria de lembrar aos comentaristas que este não é um fórum de suporte. Se você está com problemas / deseja um recurso, registre um problema . O suporte para solicitar comentários será sinalizado para exclusão.

Meu preferido é a var_dumpfunção, conforme fornecida pela extensão Xdebug : basta instalar a extensão (fácil, tanto no Windows quanto no Linux) , e var_dumpobtém uma saída melhor:

• melhor formatação
  • HTML
  • cores
• e você tem opções para ajustar quantas informações devem ser exibidas

E uma captura de tela rápida:

E, é claro, o Xdebug traz muitas outras coisas úteis, como depuração remota (ou seja, depuração gráfica do seu aplicativo PHP, no Eclipse PDT por exemplo) , criação de perfil, ...

Eu escrevi o meu próprio: REF ( demo ):

Os planos são adicionar renderização somente texto e exibir informações sobre a expressão de entrada, como o Kint ...

Aqui está o meu, que eu uso em linha, muito útil:

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

Você está procurando o Krumo ( aviso, alertas do Chrome para malware ).

Simplificando, o Krumo é um substituto para print_r () e var_dump (). Por definição, o Krumo é uma ferramenta de depuração (inicialmente para PHP4 / PHP5, agora apenas para PHP5), que exibe informações estruturadas sobre qualquer variável PHP.

Eu amo Firephp mais firebug

• Ele grava as informações de log usando cabeçalhos, para não quebrar o AJAX.
• Oferece uma representação gráfica muito boa das variáveis ​​/ objetos que você registra
• Pode exibir o nome do arquivo e o número da linha onde ocorre cada instrução de log
• Fácil de usar em seu projeto, com uma API processual ou orientada a objetos

Estou usando o dBug, que emula a incrível cfdumptag do Coldfusion :

http://dbug.ospinto.com/examples.php

Minha solução (parcial) para isso é simplesmente adicionar uma função como esta (usando o Google Chrome):

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

Pressione Ctrl + Shift + J (abre o console) e você poderá encontrar a estrutura JSON. Ainda mais útil para uma boa impressão das respostas JSON, é claro.

Um exemplo completo do que eu 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>

Saídas ...

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

Aqui é minha:

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

Estilo:

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

Recentemente, desenvolvi uma extensão gratuita do Chrome (trabalho em andamento) para embelezar meus var dumps sem bibliotecas, sem pré tags e sem instalação em todos os aplicativos. Tudo feito com JavaScript e regEx. Tudo o que você precisa fazer é instalar a extensão e pronto. Também estou trabalhando em uma versão do Firefox. Aqui está a página do GitHub. Espero tê-lo disponível nas lojas virtuais chrome e firefox em breve!

https://github.com/alexnaspo/var_dumpling

Aqui está um exemplo de saída:

Tracy tem uma bela saída recolhível usando a função dump () .

Essas bibliotecas sofisticadas são ótimas ... exceto as despesas gerais. Se você quer um var_dump simples e bonito que usa parâmetros infinitos, tente minha função. Ele adiciona um pouco de HTML simples. Também são adicionados atributos de dados. Se você usa HTML5, as versões inferiores os ignoram, mas facilita a abertura do elemento no console do navegador e a obtenção de mais informações se o que você vê na tela não for suficiente.

O layout é muito simples, sem custos adicionais. Fornece uma tonelada de informações para cada parâmetro, incluindo coisas como gettypee mesmo classnome para despejos de objetos (incluindo XML). É tentado e verdadeiro, eu tenho usado por anos.

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 você usa o Codeigniter, adicione-o também ao seu CI EXTREMAMENTE SIMPLESMENTE. Primeiro, vá application/config/autoload.phpe verifique se helper 'string'está ligado.

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

Em seguida, basta ir criar um arquivo nomeado MY_string_helper.phpem application/helperssimples e inserir a função em um típicoif declaração para o check existência.

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

| OU |, se você quiser tomar uma direção diferente.

O seguinte snippet é o mesmo que acima, exceto que mostrará suas variáveis ​​no console do navegador. Às vezes, isso pode facilitar a depuração de chamadas de objeto sql e outras chamadas de matriz e objeto em que você está perdendo o nome da chave ou o que for.

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

Funciona com tudo!

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...
<-----------------------------------------------------------------------------------------------------------------------> 

Embelezador de matriz PHP Esta ferramenta simples pega uma matriz ou objeto de saída em PHP, como uma instrução print_r (), e formata-a em código de cores para ler facilmente seus dados. http://phillihp.com/toolz/php-array-beautifier/

Mais uma versão caseira:

http://github.com/perchten/neat_html

Eu gosto de pensar que é bastante flexível. Ele não visa um ambiente de saída específico, mas possui vários argumentos opcionais que você pode especificar por que alterar a saída / impressão ou comportamento, além de algumas configurações persistentes.

Aqui está uma extensão do chrome que escrevi para resolver esse problema.

https://chrome.google.com/webstore/detail/varmasterpiece/chfhddogiigmfpkcmgfpolalagdcamkl

Desenvolvi uma extensão chrome e um plugin jquery para embelezar var_dumps

https://github.com/netfox01/fleX-debug

Se você está lidando com matrizes muito grandes em PHP, esta função pode ajudar:

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

Basicamente, despeja toda a matriz onde cada elemento está em uma linha separada, o que é benéfico para encontrar os caminhos completos certos para certos elementos.

Exemplo de saída:

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

Veja: Como exportar array PHP onde cada par de valores-chave está em uma linha separada?

Estou surpreso que ninguém tenha mencionado o código mais fácil (embora não muito bonito). Se você deseja apenas obter uma saída legível (sem cores ou recuo), é simples <pre>um var_dumptrabalho simples , como em:

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

Não é possível obter uma sobrecarga muito menor do que isso!

Eu escrevi turma pequena que é semelhante ao Krumo, mas muito mais fácil de incorporar ao aplicativo.

Aqui está o link: https://github.com/langpavel/PhpSkelet/blob/master/Classes/Debug.php

E aqui exemplo de saída: http://langpavel.php5.cz/debug_sample.html

O meu preferido é depurar em https://github.com/hazardland/debug.php, que é uma biblioteca que contém apenas uma única função chamada debug (você pode copiar essa função no seu projeto ou na sua biblioteca) . A saída html típica de debug () se parece com isso:

Mas você pode enviar dados como um texto sem formatação com a mesma função também (com quatro guias com recuo de espaço) como este (e até registrá-los em arquivo, se necessário):

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"

TVarDumper

Esta é uma ótima ferramenta que se destina a substituir a função PHP com bugs var_dumpeprint_r , uma vez que pode identificar corretamente os objetos referenciados recursivamente em uma estrutura complexa de objetos. Ele também possui um controle de profundidade recursivo para evitar a exibição recursiva indefinida de algumas variáveis ​​peculiares.

Veja: TVarDumper.php.

Por outras soluções alternativas que oferece mais vantagens em relação a var_dumpe print_re pode suportar referências circulares, por favor consulte: Usando print_r e var_dump com referência circular .

Para mais idéias, verifique também: Como você depura scripts PHP?

O meu é mais simples, para mim não tenho muito conhecimento / tempo para alterar a infraestrutura, instalar o xdebug, etc.

E em outros casos, bem, você não precisa de muito para um site simples do WP, por exemplo

Então eu uso:

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

isso realmente me ajuda muito.

mas como eu prefiro o DevConsole Environment, uso esta função incrível, mas simples:

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

Pequenos ajustes:

<?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

Outra opção é

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

Então, no seu arquivo, você apenas usa dump($var) e você acaba com uma saída como essa

Eu tive que adicionar outra resposta aqui, porque eu realmente não queria seguir as etapas das outras soluções. É extremamente simples e não requer extensões, inclui etc e é o que eu prefiro. É muito fácil e muito rápido.

Primeiro, basta json_encode a variável em questão:

echo json_encode($theResult);

Copie o resultado obtido no JSON Editor em http://jsoneditoronline.org/, basta copiá-lo no painel esquerdo, clique em Copiar> e ele imprimirá o JSON em um formato de árvore muito bom.

Para cada um deles, mas espero que isso ajude outros a terem mais uma boa opção! :)