Todo programador decente de PHP tem print_r
ou var_dump
invólucro que usa, ama e atribui teclas de atalho, por que não compartilhamos as nossas favoritas ?
Todo programador decente de PHP tem print_r
ou var_dump
invólucro que usa, ama e atribui teclas de atalho, por que não compartilhamos as nossas favoritas ?
Respostas:
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_dump
função, conforme fornecida 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 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 ...
dll
, usarei este "debug". Obrigado e bom trabalho!
Aqui está o meu, que eu uso em linha, 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: ").'<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)?'<NULL>':"<strong>$v</strong>");}return$r;};
echo $pretty($some_variable);
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 é uma função muito detalhada, ele lida com todos os casos de borda do PHP (dos quais existem MUITOS) e é 100% estável, mesmo que não seja tão legível. Mas, no final das contas, se você acha que sua implementação é melhor para você, é isso que você definitivamente deve usar.
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.
Estou usando o dBug, que emula a incrível cfdump
tag do Coldfusion :
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;
}
sbwDebug
classe que ele esqueceu de postar e colocar a função nela.
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:
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 gettype
e mesmo class
nome 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.php
e verifique se helper
'string'
está ligado.
$autoload['helper'] = array( 'string' );
Em seguida, basta ir criar um arquivo nomeado MY_string_helper.php
em application/helpers
simples 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...
<----------------------------------------------------------------------------------------------------------------------->
echo '<pre>';var_dump($var);echo '</pre>';
mais algum texto com valor zero.
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` com alguns simple html
ao seu redor, não texto com valor agregado. lol kik. Se você não gostar, não use. Apenas uma sugestão.
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
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_dump
trabalho 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"
Esta é uma ótima ferramenta que se destina a substituir a função PHP com bugs var_dump
eprint_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_dump
e print_r
e 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
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! :)