print_r - ¿Una alternativa más bonita/informativa de Var_dump en PHP?
var_dump() (23)
TVarDumper
Esta es una gran herramienta que está destinada a reemplazar la función de PHP con errores var_dump e print_r , ya que puede identificar correctamente los objetos de referencia recursiva en una estructura de objeto complejo. También tiene un control de profundidad recursivo para evitar la visualización recursiva indefinida de algunas variables peculiares.
Ver: TVarDumper .
Para otras soluciones alternativas que ofrecen más ventajas que var_dump e print_r y pueden admitir referencias circulares, compruebe: Usar print_r y var_dump con referencia circular .
Para obtener más ideas, consulte también: ¿Cómo depura los scripts PHP?
Todos los programadores de PHP decentes tienen un contenedor print_r o var_dump que usan, aman y asignan teclas de método abreviado, por qué no compartimos nuestros favoritos .
Aquí está el mío, que uso en línea, muy ú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);
Aquí esta el mio:
public function varToHtml($var='''', $key='''') {
$type = gettype($var);
$result = '''';
if (in_array($type, array(''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;
}
Diseñado 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;
}
Aquí hay una extensión de Chrome que escribí para resolver este problema.
https://chrome.google.com/webstore/detail/varmasterpiece/chfhddogiigmfpkcmgfpolalagdcamkl
Desarrollé una extensión de cromo y un plugin jquery para embellecer var_dumps
Embellecedor de matriz de PHP Esta sencilla herramienta toma una matriz u objeto de salida en PHP, como una instrucción print_r () y la formatea en código de color para leer fácilmente sus datos. http://phillihp.com/toolz/php-array-beautifier/
Esas bibliotecas de lujo son geniales ... excepto la sobrecarga. Si quieres un var_dump simple y bonito que tome infinitos parámetros, prueba mi función. Agrega un poco de HTML simple. Los atributos de datos también se agregan, si usa HTML5, las versiones más bajas simplemente los ignorarán, pero hace que sea más fácil abrir el elemento en la consola del navegador y obtener un poco más de información si lo que ve en la pantalla no es suficiente.
El diseño es muy simple, sin gastos generales. Proporciona una gran cantidad de información para cada parámetro, incluyendo cosas como gettype e incluso el nombre de la class para los volcados de objetos (incluido XML). Es probado y cierto, lo he estado usando durante años.
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;
}
Y si usa Codeigniter, agréguelo también su CI EXTREMADAMENTE SIMPLEMENTE. Primero, vaya a application/config/autoload.php y asegúrese de que el helper ''string'' esté activado.
$autoload[''helper''] = array( ''string'' );
Luego, simplemente vaya a crear un archivo llamado MY_string_helper.php en application/helpers e inserte la función en una instrucción if típica para verificar la existencia.
<?php if (!defined(''BASEPATH'')) exit(''No direct script access allowed'');
if (!function_exists(''preDump'')) {
function preDump() {
...
}
}
// DON''T CLOSE PHP
| O |, si quieres tomar una dirección diferente.
El siguiente fragmento es el mismo que el anterior, excepto que mostrará sus variables en la consola del navegador. Esto a veces puede hacer que sea más fácil depurar llamadas a objetos sql y otras llamadas a arreglos y objetos donde falta el nombre de la clave o lo que sea.
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 con todo!
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...
<----------------------------------------------------------------------------------------------------------------------->
Escribí una clase pequeña que es similar a Krumo, pero mucho más fácil de integrar a la aplicación.
Aquí hay un enlace: https://github.com/langpavel/PhpSkelet/blob/master/Classes/Debug.php
Y aquí muestra el resultado: http://langpavel.php5.cz/debug_sample.html
Está buscando Krumo ( Advertencia, alertas de Chrome para Malware ).
Para decirlo simplemente, Krumo es un reemplazo para print_r () y var_dump (). Por definición, Krumo es una herramienta de depuración (inicialmente para PHP4 / PHP5, ahora solo para PHP5), que muestra información estructurada sobre cualquier variable de PHP.
Hace poco desarrollé una extensión gratuita de Chrome (trabajo en progreso) para embellecer mis volcados de var sin bibliotecas, sin preetiquetas y sin instalación en todas y cada una de las aplicaciones. Todo hecho con JavaScript y regEx. Todo lo que tienes que hacer es instalar la extensión y listo. Estoy trabajando en una versión de Firefox también. Aquí está la página de GitHub. ¡Espero tenerlo disponible en las tiendas web de cromo y firefox pronto!
https://github.com/alexnaspo/var_dumpling
Aquí hay un ejemplo de salida:
He estado usando dBug, que emula la impresionante etiqueta cfdump Coldfusion:
Me encanta Firephp más firebug
- Escribe la información de registro utilizando encabezados, por lo que no rompe AJAX.
- Te da una muy buena representación gráfica de las variables / objetos que registras
- Puede mostrar el nombre del archivo y el número de línea donde se produce cada declaración de registro
- Fácil de usar en su proyecto, ya sea con una API procesal u orientada a objetos
Me sorprende que nadie haya mencionado el código más fácil (aunque no muy bonito). Si solo desea obtener una salida legible (sin colores o indentación), un simple <pre> alrededor de var_dump funciona, como en:
echo "<pre>";
var_dump($myvariable);
echo "</pre>";
No se puede obtener mucho más por encima que esto!
Mi preferencia es la función var_dump , tal como lo proporciona la extensión Xdebug : simplemente instale la extensión (fácil, tanto en Windows como en Linux) , y var_dump obtiene un mejor resultado:
- mejor formateo
- HTML
- colores
- y tienes opciones para ajustar la cantidad de información que se debe mostrar
Y una captura de pantalla rápida:
Y, por supuesto, Xdebug trae muchas otras cosas útiles, como la depuración remota (es decir, la depuración gráfica de su aplicación PHP, por ejemplo en Eclipse PDT) , creación de perfiles, ...
Mi preferido es la depuración de https://github.com/hazardland/debug.php que es una biblioteca que contiene solo una función llamada depuración (solo puede copiar esa función en su proyecto o en su biblioteca) . El resultado típico de depuración de html () se ve así:
Pero también puede generar datos como un texto sin formato con la misma función (con 4 espacios de sangría) como este (e incluso registrarlo en el archivo si es necesario):
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"
Mi solución (parcial) para esto es simplemente agregar una función como esta (usando Google Chrome):
<?
function console_dump($value)
{
?>
<script>
console.log(<? echo json_encode($value); ?>);
</script>
<?
}
?>
Presione Ctrl + Shift + J (abre la consola), y puede encontrar allí la estructura JSON. Aún más útil para una bonita impresión de respuestas JSON, por supuesto.
Para hacer la lista más completa: los desarrolladores de Symfony lanzaron una alternativa de dumper independiente utilizable como independiente:
https://github.com/symfony/var-dumper
Puedes leer más sobre esto aquí:
http://www.sitepoint.com/var_dump-introducing-symfony-vardumper/
Si se trata de matrices muy grandes en PHP, esta función puede ayudar:
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;
}
Básicamente, vuelca toda la matriz donde cada elemento está en una línea separada, lo que es beneficioso para encontrar las rutas completas correctas para ciertos elementos.
Ejemplo de salida:
$a = array();
$a[0] = 1;
$a[1] = 2;
$a[2] = array();
$a[2][0] = ''a'';
$a[2][1] = ''b'';
$a[2][2] = ''c'';
Ver: ¿Cómo exportar PHP array donde cada par clave-valor está en línea separada?
Sin embargo, otra versión local:
http://github.com/perchten/neat_html
Me gusta pensar que es bastante flexible. No apunta a un entorno de salida particular, pero tiene un montón de argumentos opcionales, puede especificar por qué cambiar la salida / impresión o el comportamiento, así como algunas configuraciones persistentes.
Un año completo de trabajo después de preguntar esto, finalmente abrí mi versión de var_dump, Kint. Lea sobre esto en la página del proyecto , o directamente en github .
Aquí hay una captura de pantalla:
Perdón por el enchufe :)
EDITAR: Me gustaría recordarles a los comentaristas que este no es un foro de soporte. Si tiene problemas / desea una función, por favor presente un problema . El soporte que solicita comentarios se marcará para su eliminación.
Un ejemplo completo de lo que 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>
Salidas ...
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
Tracy tiene una hermosa salida colapsable utilizando la función dump () .