Todo programador decente de PHP tem um wrapper print_r
ou var_dump
eles usam, amam e atribuem chaves de atalho, porque não compartilhamos nossos favoritos .
Um ano inteiro de trabalho e trabalho depois de perguntar isso, eu 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 canvas:
Desculpe pelo plugue 🙂
EDIT: Gostaria apenas de lembrar aos comentadores, que este não é um fórum de suporte, se você estiver tendo problemas / quiser um recurso, por favor, envie um problema . O suporte para solicitar comentários será marcado para exclusão.
Minha opção preferida é a function var_dump
, conforme fornecido pela extensão Xdebug : basta instalar a extensão (fácil, tanto no Windows quanto no Linux) e var_dump
obtém uma saída melhor:
E uma captura de canvas rápida:
E, claro, o Xdebug traz muitas outras coisas úteis, como debugging remota (ou seja, debugging gráfica de sua aplicação PHP, no Eclipse PDT, por exemplo) , criação de perfil, …
Eu escrevi o meu próprio: REF ( demo ):
Os planos são para adicionar renderização somente de texto e exibir informações sobre a expressão de input, como o Kint faz …
Aqui é o meu, que eu uso inline, muito útil:
$pretty = function($v='',$c=" ",$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: ").'
';foreach($v as $sk=>$vl){$r.=$pretty($vl,$c,$in+1,$sk).'
';}}else{$r.=($in!=-1?str_repeat($c,$in):'').(is_null($k)?'':"$k: ").(is_null($v)?'<NULL>':"$v");}return$r;}; echo $pretty($some_variable);
Você está procurando por Krumo ( Aviso, alertas do Chrome para Malware ).
Simplificando, Krumo é um substituto para print_r () e var_dump (). Por definição Krumo é uma ferramenta de debugging (inicialmente para PHP4 / PHP5, agora apenas para PHP5), que exibe informações estruturadas sobre qualquer variável PHP.
Eu adoro Firephp plus firebug
Minha solução (parcial) para isso é simplesmente adicionar uma function como essa (usando o Google Chrome):
< ? function console_dump($value) { ?> < ? } ?>
Pressione Ctrl + Shift + J (abre o console), e você pode encontrar a estrutura JSON. Ainda mais útil para uma linda impressão das respostas da JSON, é claro.
Eu tenho usado o dBug, que emula a incrível tag cfdump
do Coldfusion:
Um exemplo completo do que eu uso …
< ?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); ?>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:
public function varToHtml($var='', $key='') { $type = gettype($var); $result = ''; if (in_array($type, array('object','array'))) { $result .= ' '.$key.'
Type: '.$type.'
Length: '.count($var).' '; foreach ($var as $akey => $val) { $result .= sbwDebug::varToHtml($val, $akey); } $result .= '
'; } else { $result .= ''.$key.' ('.$type.'): '.$var.''; } return $result; }
Denominado com:
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 cromada gratuita (trabalho em andamento), a fim de embelezar os meus despejos variados sem bibliotecas, sem pré tags e sem instalação para cada aplicativo. Tudo feito com JavaScript e regEx. Tudo o que você precisa fazer é instalar a extensão e o seu bom para ir. Estou também trabalhando em uma versão do Firefox. Aqui está a página GitHub. Espero ter disponível no Chrome e no Firefox agora mesmo!
https://github.com/alexnaspo/var_dumpling
Aqui está um exemplo de saída:
Tracy tem uma saída atraente bonita usando a function dump () .
Essas bibliotecas extravagantes são ótimas … exceto as despesas gerais. Se você quiser um var_dump simples e bonito que leve parâmetros infinitos, tente minha function. Ele adiciona um HTML simples. Os atributos de dados também são adicionados, se você usar o HTML5, as versões mais baixas simplesmente ignorá-los, mas facilita a abertura do elemento no console do navegador e obtenha um pouco mais de informações se o que você vê na canvas não é suficiente.
O layout é muito simples, sem sobrecarga. Fornece uma tonelada de informações para cada parâmetro, incluindo coisas como gettype
e até mesmo o nome da class
para despejos de objects (incluindo XML). É tentado e verdadeiro, eu tenho usado isso há anos.
function preDump() { // use string "noEcho" to just get a string return only $args = func_get_args(); $doEcho = TRUE; $sb; if ($args) { $sb = '
'; } else { $sb = '
'; } if ($doEcho) echo($sb); return $sb; }
E se você usa o Codeigniter, adicione-o também o seu CI EXTREMADAMENTE SIMPLESMENTE. Primeiro, vá para
application/config/autoload.php
e verifique se ohelper
'string'
está ativado.$autoload['helper'] = array( 'string' );
Em seguida, basta ir criar um arquivo chamado
MY_string_helper.php
emapplication/helpers
e inserir a function em uma declaração típicaif
forif
de 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 seguir uma direção diferente.
O seguinte fragment é o mesmo que acima, exceto mostrará suas variables no console do navegador. Isso pode, às vezes, tornar mais fácil a debugging de chamadas de object sql e outras chamadas de matrizes e objects, onde 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 = ''; } else { $sb = ''; } 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... < ----------------------------------------------------------------------------------------------------------------------->
Para tornar a lista mais completa – os desenvolvedores da Symfony lançaram uma alternativa de dumper utilizável como autônomo:
https://github.com/symfony/var-dumper
Você pode ler sobre isso mais aqui:
http://www.sitepoint.com/var_dump-introducing-symfony-vardumper/
Eu escrevi uma class 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 o resultado da amostra: http://langpavel.php5.cz/debug_sample.html
PHP Array Beautifier Esta ferramenta simples leva uma matriz ou saída de object em PHP, como uma declaração print_r () e formata-a em codificação de colors para ler facilmente seus dados. http://phillihp.com/toolz/php-array-beautifier/
Ainda outra versão caseira:
http://github.com/perchten/neat_html
Eu gosto de pensar que é bastante flexível. Não tem como objective um ambiente de saída específico, mas tem um monte de argumentos opcionais, você pode especificar por que alterar a saída / impressão ou comportamento, bem como algumas configurações persistentes.
Aqui está uma extensão de cromo que escrevi para resolver esse problema.
https://chrome.google.com/webstore/detail/varmasterpiece/chfhddogiigmfpkcmgfpolalagdcamkl
Desenvolvi uma extensão cromada e um plugin jquery para embelezar var_dumps
O meu preferido é o debug de https://github.com/hazardland/debug.php, que é uma biblioteca com apenas uma function denominada como debugging (você pode simplesmente copiar essa function no seu projeto ou em sua biblioteca) . A saída típica debug () html parece assim:
Mas você pode enviar dados como um texto simples com a mesma function também (com 4 guias com indentação de espaço) como esse (e até mesmo log-lo no 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"
Se você está lidando com matrizes muito grandes em PHP, esta function pode ajudar:
function recursive_print ($varname, $varval) { if (! is_array($varval)): print $varname . ' = ' . var_export($varval, true) . ";
\n"; else: print $varname . " = array();
\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á na linha separada, o que é benéfico para encontrar os caminhos certos e certos para determinados 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 a matriz PHP onde cada par chave-valor está em linha separada?
Estou surpreso por ninguém ter mencionado o código mais fácil (embora não muito bonito). Se você quiser apenas obter uma saída legível (sem colors ou indentação), um simples
torno de um var_dump
funciona, como em:
echo "
"; var_dump($myvariable); echo "";
Não pode ser muito mais baixo do que isso!
Esta é uma ótima ferramenta que se destina a replace a function PHP buggy var_dump
e print_r
, uma vez que pode identificar corretamente os objects recursivamente referenciados em uma estrutura de object complexa. Ele também possui um controle de profundidade recursiva para evitar a exibição recursiva indefinida de algumas variables peculiares.
Veja: TVarDumper.php
.
Para outras soluções alternativas que oferecem mais vantagens sobre var_dump
e print_r
e podem suportar referências circulares, verifique: Usando print_r e var_dump com referência circular .
Para mais ideias, verifique também: como você depura scripts PHP?