¿Una alternativa Var_dump más bonita / informativa en PHP? [cerrado]

Cada programador PHP decente tiene un print_ro var_dumpcontenedor que usan, aman y asignan teclas de acceso directo, ¿por qué no compartimos nuestras favoritas ?

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_dumpfunción, como lo proporciona la extensión Xdebug : simplemente instale la extensión (fácil, tanto en Windows como en Linux) , y var_dumpobtenga un mejor resultado:

• mejor formateo
  • HTML
  • colores
• y tiene 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, en Eclipse PDT, por ejemplo) , perfiles, ...

Escribí el mío: REF ( demo ):

Los planes son agregar una representación de solo texto y mostrar información sobre la expresión de entrada como lo hace Kint ...

Aquí está el mío, que uso en línea, muy ú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);

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

• Escribe la información de registro utilizando encabezados, por lo que no rompe AJAX.
• Le brinda una representación gráfica muy agradable de las variables / objetos que registra
• 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 de procedimiento u orientada a objetos

He estado usando dBug, que emula la increíble cfdumpetiqueta de Coldfusion :

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

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

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 gettypee incluso classnombres 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.phpy 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.phpde application/helpersy simple inserción de la función en una típica ifdeclaració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...
<-----------------------------------------------------------------------------------------------------------------------> 

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

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

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_dumpfunciona, 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"

TVarDumper

Esta es una gran herramienta que está destinada a reemplazar la función PHP defectuosa var_dumpy 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_dumpy print_rpueden 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

Otra opción es

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

Luego, en su archivo, simplemente usa dump($var) y terminará con una salida como esta

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