Une alternative Var_dump plus jolie / informative en PHP? [fermé]

Chaque programmeur PHP décent a un print_rou un var_dumpwrapper qu'il utilise, aime et attribue des touches de raccourci, pourquoi ne partageons- nous pas nos préférés .

Une année complète de temps et de travail après avoir posé cette question, j'ai enfin ouvert ma version de var_dump, Kint. Renseignez-vous sur la page du projet ou directement dans github .

Voici une capture d'écran:

Désolé pour la prise :)

EDIT: Je voudrais juste rappeler aux commentateurs, que ce n'est pas un forum de support, si vous rencontrez des problèmes / souhaitez une fonctionnalité, veuillez déposer un problème . Le support demandant des commentaires sera signalé pour suppression.

Mon préféré est la var_dumpfonction, fournie par l'extension Xdebug : il suffit d'installer l'extension (facile, à la fois sous Windows et Linux) , et var_dumpobtenir un meilleur résultat:

• meilleure mise en forme
  • HTML
  • couleurs
• et vous avez des options pour régler la quantité d'informations à afficher

Et une capture d'écran rapide:

Et, bien sûr, Xdebug apporte plein d'autres trucs utiles, comme le débogage à distance (c'est-à-dire le débogage graphique de votre application PHP, dans Eclipse PDT par exemple) , le profilage, ...

J'ai écrit le mien: REF ( démo ):

Les plans sont d'ajouter un rendu de texte uniquement et d'afficher des informations sur l'expression d'entrée comme le fait Kint ...

Voici le mien, que j'utilise en ligne, très utile:

$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);

Vous recherchez Krumo ( Attention, alertes Chrome pour Malware ).

Pour faire simple, Krumo remplace print_r () et var_dump (). Par définition, Krumo est un outil de débogage (initialement pour PHP4 / PHP5, maintenant pour PHP5 uniquement), qui affiche des informations structurées sur n'importe quelle variable PHP.

J'adore Firephp plus Firebug

• Il écrit les informations de journalisation à l'aide d'en-têtes, de sorte qu'il ne brise pas AJAX.
• Vous donne une très belle représentation graphique des variables / objets que vous enregistrez
• Peut afficher le nom du fichier et le numéro de ligne où chaque instruction de journal se produit
• Facile à utiliser dans votre projet, que ce soit avec une API procédurale ou orientée objet

J'utilise dBug, qui émule le génial cfdumptag de Coldfusion :

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

Ma solution (partielle) pour cela est d'ajouter simplement une fonction comme celle-ci (en utilisant Google Chrome):

<?
function console_dump($value)
{ 
?>
<script>
    console.log(<? echo json_encode($value); ?>);
</script>
<?
}
?>

Appuyez sur Ctrl + Maj + J (ouvre la console), et vous pouvez y trouver la structure JSON. Encore plus utile pour une jolie impression des réponses JSON bien sûr.

Un exemple complet de ce que j'utilise ...

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

Les sorties ...

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

Voici le mien:

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

Conçu avec:

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

J'ai récemment développé une extension chrome gratuite (travail en cours) afin d'embellir mes vidages var sans bibliothèques, sans balises pré et sans installation sur chaque application. Tout est fait avec JavaScript et regEx. Tout ce que vous avez à faire est d'installer l'extension et vous êtes prêt à partir. Je travaille également sur une version de Firefox. Voici la page GitHub. J'espère l'avoir bientôt disponible sur les boutiques en ligne Chrome et Firefox!

https://github.com/alexnaspo/var_dumpling

Voici un exemple de sortie:

Tracy a une belle sortie à l' aide collapsable dump () fonction .

Ces bibliothèques sophistiquées sont super ... sauf les frais généraux. Si vous voulez un simple et joli var_dump qui prend des paramètres infinis, essayez ma fonction. Il ajoute du HTML simple. Les attributs de données sont également ajoutés.Si vous utilisez HTML5, les versions inférieures les ignoreront simplement, mais faciliteront l'ouverture de l'élément dans la console du navigateur et obtiendront un peu plus d'informations si ce que vous voyez à l'écran ne suffit pas.

La mise en page est très simple, sans frais généraux. Fournit une tonne d'informations pour chaque paramètre, y compris des choses comme gettypeet mêmeclass nom des vidages d'objets (y compris XML). C'est essayé et vrai, je l'utilise depuis des années.

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

Et si vous utilisez Codeigniter, ajoutez-le aussi à votre CI EXTRÊMEMENT SIMPLEMENT. Tout d'abord, allez à application/config/autoload.phpet assurez-vous que lehelper 'string' est activé.

$autoload['helper'] = array( 'string' ); 

Ensuite, créez simplement un fichier nommé MY_string_helper.phpdans application/helperset insérez simplement la fonction dans une ifdéclaration typique de vérification d'existence.

<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
    if (!function_exists('preDump')) {
        function preDump() {
            ...
        }
    }
//  DON'T CLOSE PHP

| OU |, si vous voulez prendre une autre direction.

L'extrait suivant est le même que ci-dessus, sauf qu'il affichera vos variables dans la console du navigateur. Cela peut parfois faciliter le débogage des appels d'objet SQL et d'autres appels de tableau et d'objet où vous manquez le nom de la clé ou autre.

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

Fonctionne avec tout!

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 Cet outil simple prend un tableau ou une sortie d'objet en PHP, comme une instruction print_r () et le formate en code couleur pour lire facilement vos données. http://phillihp.com/toolz/php-array-beautifier/

Encore une autre version locale:

http://github.com/perchten/neat_html

J'aime penser que c'est assez flexible. Il ne vise pas un environnement de sortie particulier mais a un tas d'arguments optionnels vous pouvez spécifier pourquoi changer la sortie / impression ou le comportement, ainsi que certains paramètres persistants.

Voici une extension chrome que j'ai écrite pour résoudre ce problème.

https://chrome.google.com/webstore/detail/varmasterpiece/chfhddogiigmfpkcmgfpolalagdcamkl

J'ai développé une extension chrome et un plugin jquery afin d'embellir var_dumps

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

Si vous avez affaire à de très gros tableaux en PHP, cette fonction peut vous aider:

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

Il vide essentiellement tout le tableau où chaque élément est sur une ligne distincte, ce qui est bénéfique pour trouver les bons chemins complets pour certains éléments.

Exemple de sortie:

$a = array();
$a[0] = 1;
$a[1] = 2;
$a[2] = array();
$a[2][0] = 'a';
$a[2][1] = 'b';
$a[2][2] = 'c';

Voir: Comment exporter un tableau PHP où chaque paire clé-valeur est sur une ligne distincte?

Je suis surpris que personne n'ait mentionné le code le plus simple (mais pas très joli). Si vous voulez juste obtenir une sortie lisible (sans couleurs ni indentation), un simple <pre>autour d'une var_dumpœuvre, comme dans:

echo "<pre>";
var_dump($myvariable);
echo "</pre>";

Vous ne pouvez pas obtenir des frais généraux beaucoup plus bas!

J'ai écrit une petite classe similaire à Krumo, mais beaucoup plus facile à intégrer à l'application.

Voici le lien: https://github.com/langpavel/PhpSkelet/blob/master/Classes/Debug.php

Et voici un exemple de sortie: http://langpavel.php5.cz/debug_sample.html

Mon préféré est le débogage de https://github.com/hazardland/debug.php qui est une bibliothèque contenant une seule fonction nommée débogage (vous pouvez simplement copier cette fonction dans votre projet ou dans votre bibliothèque) . La sortie html typique de debug () ressemble à ceci:

Mais vous pouvez également générer des données sous forme de texte brut avec la même fonction (avec 4 tabulations en retrait d'espacement) comme ceci (et même les enregistrer dans un fichier si nécessaire):

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

C'est un excellent outil destiné à remplacer la fonction PHP boguée var_dumpetprint_r , puisqu'il peut identifier correctement les objets référencés récursivement dans une structure d'objets complexe. Il dispose également d'un contrôle de profondeur récursif pour éviter l'affichage récursif indéfini de certaines variables particulières.

Voir: TVarDumper.php.

Pour d' autres solutions alternatives qui offre plus d' avantages sur var_dumpet print_ret peut supporter des références circulaires, s'il vous plaît vérifier: Utiliser print_r et var_dump en référence circulaire .

Pour plus d'idées, consultez également: Comment déboguez-vous les scripts PHP?

Le mien, c'est un plus simple, pour moi je n'ai pas beaucoup de connaissances / de temps pour changer d'infrastructure installer xdebug, etc etc.

Et dans d'autres cas, eh bien vous n'avez pas besoin de grand chose pour un simple site Web WP par exemple

J'utilise donc:

highlight_string("\n<?" . var_export($var, true) . "?>\n");

cela m'aide vraiment beaucoup.

mais parce que je préfère l'environnement DevConsole, j'utilise cette fonction géniale mais simple:

https://codeinphp.github.io/post/outputting-php-to-browser-console/

Petit tweak:

<?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

Une autre option consiste à

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

Ensuite, dans votre fichier, vous utilisez simplement dump($var) et vous vous retrouverez avec une sortie comme celle-ci

J'ai dû ajouter une autre réponse ici car je ne voulais pas vraiment passer par les étapes des autres solutions. C'est extrêmement simple et ne nécessite aucune extension, inclut, etc. et c'est ce que je préfère. C'est très simple et très rapide.

Tout d'abord, json_encode la variable en question:

echo json_encode($theResult);

Copiez le résultat que vous obtenez dans l'éditeur JSON à http://jsoneditoronline.org/, copiez-le simplement dans le volet de gauche, cliquez sur Copier> et il imprime assez le JSON dans un très joli format d'arbre.

À chacun le leur, mais j'espère que cela aidera certains autres à avoir une autre option intéressante! :)