Une alternative plus jolie/informative avec Var_dump en PHP?
Chaque bon programmeur PHP dispose d'un wrapper print_r ou var_dump qu'il utilise, aime et attribue des touches de raccourci, pourquoi ne pas partager nos favoris.
Une année complète de travail et de temps après avoir posé cette question, j'ai finalement ouvert ma version de var_dump, Kint. Lire à ce sujet dans 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 sollicitant des commentaires sera marqué pour suppression.
Mon préféré est la fonction var_dump, fournie par l’extension Xdebug : il suffit d’installer l’extension (facile, à la fois sous Windows et sous Linux) , et var_dump obtient un meilleur résultat:
- mieux formater
- HTML
- couleurs
- et vous avez des options pour régler combien d'informations doivent être affichées
Et une capture d'écran rapide:
Et, bien sûr, Xdebug apporte de nombreuses autres choses utiles, telles que le débogage à distance (c'est-à-dire le débogage graphique de votre application PHP, dans Eclipse PDT par exemple ) , profilage, ...
Voici le mien, que j'utilise en ligne, très utile:
$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);
Vous recherchez Krumo (Warning, alertes Chrome pour Malware).
Pour le dire simplement, Krumo est un remplacement pour print_r () et var_dump (). Par définition, Krumo est un outil de débogage (initialement pour PHP4/PHP5, maintenant uniquement pour PHP5), qui affiche des informations structurées sur toutes les variables PHP.
- Il écrit les informations de journalisation En utilisant des en-têtes, pour ne pas casser 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ù se trouve chaque instruction de journal
- Facile à utiliser dans votre projet, avec une API procédurale ou orientée objet
Ma solution (partielle) consiste simplement à ajouter une fonction comme celle-ci (avec Google Chrome):
<?
function console_dump($value)
{
?>
<script>
console.log(<? echo json_encode($value); ?>);
</script>
<?
}
?>
Appuyez sur Ctrl + Maj + J (ouvre la console) pour y trouver la structure JSON. Encore plus utile pour une jolie impression de réponses JSON ofcourse.
J'utilise dBug, qui émule l'impressionnant tag cfdump de Coldfusion:
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:
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;
}
Style 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 (travaux en cours) afin d'embellir mes dumps var sans bibliothèques, pré-tags et aucune installation pour 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 aussi sur une version de Firefox. Voici la page GitHub. J'espère l'avoir bientôt disponible dans les boutiques en ligne Chrome et Firefox!
https://github.com/alexnaspo/var_dumpling
Voici un exemple de sortie:
Tracy a une belle sortie compressible utilisant dump () function .
Ces bibliothèques sophistiquées sont excellentes ... sauf les frais généraux. Si vous voulez un var_dump simple et joli 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 les plus basses les ignoreront tout simplement, mais il sera plus facile d'ouvrir un élément dans la console du navigateur et d'obtenir un peu plus d'informations si ce que vous voyez à l'écran ne suffit pas.
La mise en page est très simple, pas de frais généraux. Fournit une tonne d'informations pour chaque paramètre, y compris des éléments tels que gettype et même class nom pour les vidages d'objet (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-y aussi votre CI EXTREMELY SIMPLY. Tout d’abord, allez à application/config/autoload.php et assurez-vous que la helper'string' est activée.
$autoload['helper'] = array( 'string' );
Ensuite, créez simplement un fichier nommé MY_string_helper.php dans application/helpers et insérez simplement la fonction dans une instruction if typique pour le contrôle 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 direction différente.
L'extrait suivant est le même que ci-dessus, sauf que vos variables seront affichées dans la console du navigateur. Cela peut parfois faciliter le débogage des appels d’objets SQL et d’autres appels d’objets de tableaux et d’objets pour lesquels le nom de la clé est manquant.
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...
<----------------------------------------------------------------------------------------------------------------------->
Pour rendre la liste plus complète, les développeurs Symfony ont publié une alternative dumper utilisable en tant que autonome:
https://github.com/symfony/var-dumper
Vous pouvez lire plus à ce sujet ici:
http://www.sitepoint.com/var_dump-introducing-symfony-vardumper/
Ma préférence est debug} de https://github.com/hazardland/debug.php qui est une bibliothèque avec une seule fonction nommée debug} _ (vous pouvez copiez simplement cette fonction dans votre projet ou dans votre bibliothèque). La sortie typique de debug () _ html ressemble à ceci:
Mais vous pouvez aussi exporter les données sous forme de texte brut avec la même fonction (avec 4 onglets indentés) (et même le consigner 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"
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
Une autre option est de
composer require symfony/var-dumper --save-dev
Ensuite, dans votre fichier, vous utilisez simplement dump($var) et vous obtiendrez une sortie comme celle-ci 
Encore une autre version maison:
http://github.com/perchten/neat_html
J'aime penser que c'est assez flexible. Il ne vise pas un environnement de sortie particulier, mais contient une série d'arguments facultatifs que vous pouvez spécifier, notamment pourquoi modifier la sortie/l'impression ou le comportement, ainsi que certains paramètres persistants.
PHP Array Beautifier Cet outil simple prend une sortie de tableau ou d'objet en PHP, telle qu'une instruction print_r (), et la formate en code couleur pour une lecture facile de vos données . http://phillihp.com/ toolz/php-array-beautifier/
J'ai développé une extension chrome et jquery plugin afin d'embellir var_dumps
Voici une extension chrome que j'ai écrite pour résoudre ce problème.
https://chrome.google.com/webstore/detail/varmasterpiece/chfhddogiigmfpkcmgfpolalagdcamkl
Si vous utilisez de très grands 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;
}
En gros, il vide tout le tableau où chaque élément est placé dans une ligne séparée, ce qui est bénéfique pour trouver les chemins complets appropriés 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 séparée?
Le mien est plus simple, pour moi je n'ai pas beaucoup de connaissances/temps pour changer d'infrastructure, installer xdebug, etc.
Et dans d'autres cas, vous n'avez pas besoin de beaucoup pour un simple WP site Web, par exemple
Donc j'utilise:
highlight_string("\n<?" . var_export($var, true) . "?>\n");
cela m'aide beaucoup.
mais parce que je préfère l'environnement DevConsole, j'utilise cette fonction simple mais impressionnante:
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