Cada programador PHP decente tiene un print_r
o var_dump
contenedor que usan, aman y asignan teclas de acceso directo, ¿por qué no compartimos nuestras favoritas ?
Cada programador PHP decente tiene un print_r
o var_dump
contenedor que usan, aman y asignan teclas de acceso directo, ¿por qué no compartimos nuestras favoritas ?
Respuestas:
Un año completo de tiempo y trabajo después de preguntar esto, finalmente he abierto 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, presente un problema . El soporte para solicitar comentarios se marcará para su eliminación.
Lo que prefiero es la var_dump
función, como lo proporciona la extensión Xdebug : simplemente instale la extensión (fácil, tanto en Windows como en Linux) , y var_dump
obtenga un mejor resultado:
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, en Eclipse PDT, por ejemplo) , perfiles, ...
Los planes son agregar una representación de solo texto y mostrar información sobre la expresión de entrada como lo hace Kint ...
dll
, usaré esta "depuración". ¡Gracias y buen trabajo!
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);
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 es una función muy detallada, maneja todos los casos extremos de PHP (de los cuales hay MUCHOS) y es 100% estable, aunque no tan legible. Pero al final del día, si encuentra que su implementación es la mejor para usted, es lo que definitivamente debe usar.
Está buscando Krumo ( Advertencia, alertas de Chrome para malware ).
En pocas palabras, 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.
Me encanta Firephp plus firebug
He estado usando dBug, que emula la increíble cfdump
etiqueta de Coldfusion :
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.
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
Aquí esta el 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;
}
}
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;
}
sbwDebug
clase que olvidó publicar y poner la función en ella.
Recientemente desarrollé una extensión gratuita de Chrome (trabajo en progreso) para embellecer mis volcados var sin bibliotecas, sin etiquetas previas 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 Chrome y Firefox pronto!
https://github.com/alexnaspo/var_dumpling
Aquí hay un ejemplo de salida:
Tracy tiene una hermosa salida plegable usando dump () la función .
Esas elegantes bibliotecas son geniales ... excepto los gastos generales. Si quieres una var_dump simple y bonita que tome parámetros infinitos, prueba mi función. Agrega algo de HTML simple. Los atributos de datos también se agregan, si usa HTML5, las versiones inferiores simplemente los ignorarán, pero hacen que sea 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 tonelada de información para cada parámetro, incluyendo cosas como gettype
e incluso class
nombres para volcados de objetos (incluido XML). Está probado y es 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 a su CI EXTREMADAMENTE SIMPLEMENTE. Primero, ve application/config/autoload.php
y asegúrate de que helper
'string'
esté encendido.
$autoload['helper'] = array( 'string' );
Después, simplemente vaya a crear un archivo con el nombre MY_string_helper.php
de application/helpers
y simple inserción de la función en una típica if
declaración de verificación de la existencia.
<?php if (!defined('BASEPATH')) exit('No direct script access allowed');
if (!function_exists('preDump')) {
function preDump() {
...
}
}
// DON'T CLOSE PHP
| O |, si desea 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 facilitar la depuración de las llamadas a objetos sql y otras llamadas a objetos y matrices en las que 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...
<----------------------------------------------------------------------------------------------------------------------->
echo '<pre>';var_dump($var);echo '</pre>';
más un texto de valor cero.
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 algunos simple html
a su alrededor, no texto de valor agregado 0. jajaja kik Si no te gusta, no lo uses. Sólo una sugerencia.
PHP Array Beautifier Esta herramienta simple toma una salida de matriz u objeto en PHP, como una declaración print_r () y la formatea en código de colores para leer fácilmente sus datos. http://phillihp.com/toolz/php-array-beautifier/
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 que puede especificar por qué cambiar la salida / impresión o el comportamiento, así como algunas configuraciones persistentes.
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 Chrome y un complemento de jquery para embellecer var_dumps
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.
Salida de ejemplo:
$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 una matriz PHP donde cada par clave-valor está en una línea separada?
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 ni sangría), un simple <pre>
entorno var_dump
funciona, como en:
echo "<pre>";
var_dump($myvariable);
echo "</pre>";
¡No se puede obtener gastos generales mucho más bajos que esto!
Escribí una clase pequeña que es similar a Krumo, pero mucho más fácil de insertar en la aplicación.
Aquí está el enlace: https://github.com/langpavel/PhpSkelet/blob/master/Classes/Debug.php
Y aquí salida de muestra: http://langpavel.php5.cz/debug_sample.html
Mi preferido es la depuración de https://github.com/hazardland/debug.php, que es una biblioteca que contiene solo una función llamada debug (puede copiar esa función en su proyecto o en su biblioteca) . La salida html debug () típica se ve así:
Pero puede generar datos como texto sin formato con la misma función también (con 4 pestañas con sangría de espacio) como esta (e incluso iniciar sesión 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"
Esta es una gran herramienta que está destinada a reemplazar la función PHP defectuosa var_dump
y print_r
, ya que puede identificar correctamente los objetos referenciados recursivamente en una estructura de objeto compleja. También tiene un control de profundidad recursivo para evitar la visualización recursiva indefinida de algunas variables peculiares.
Ver: TVarDumper.php
.
Para otras soluciones alternativas que brindan más ventajas sobre var_dump
y print_r
pueden admitir referencias circulares, consulte: Uso de print_r y var_dump con referencia circular .
Para obtener más ideas, consulte también: ¿Cómo se depuran los scripts PHP?
La mía, es más simple, para mí no tengo mucho conocimiento / tiempo para cambiar la infraestructura, instalar xdebug, etc.
Y en otros casos, bueno, no necesitas mucho para un simple sitio web de WP, por ejemplo
Entonces uso:
highlight_string("\n<?" . var_export($var, true) . "?>\n");
eso realmente me ayuda mucho.
pero debido a que prefiero el entorno DevConsole, uso esta increíble pero simple función:
https://codeinphp.github.io/post/outputting-php-to-browser-console/
Pequeño ajuste:
<?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
Tuve que agregar otra respuesta aquí porque realmente no quería seguir los pasos de las otras soluciones. Es extremadamente simple y no requiere extensiones, incluye etc. y es lo que prefiero. Es muy fácil y muy rápido.
Primero solo json_encode la variable en cuestión:
echo json_encode($theResult);
Copie el resultado que obtiene en el Editor JSON en http://jsoneditoronline.org/ simplemente cópielo en el panel lateral izquierdo, haga clic en Copiar> e imprime el JSON en un formato de árbol realmente agradable.
Para cada uno lo suyo, pero espero que esto ayude a otros a tener una buena opción más. :)