Y a-t-il une jolie impression pour PHP?

Je corrige quelques scripts PHP et il me manque la jolie imprimante de ruby. c'est à dire

require 'pp'
arr = {:one => 1}
pp arr

affichera {: one => 1}. Cela fonctionne même avec des objets assez complexes et facilite grandement l'exploration d'un script inconnu. Existe-t-il un moyen de dupliquer cette fonctionnalité en PHP?

Les deux print_r()et var_dump()produiront des représentations visuelles des objets dans PHP.

$arr = array('one' => 1);
print_r($arr);
var_dump($arr);

Voici ce que j'utilise pour imprimer mes tableaux:

<pre>
    <?php
        print_r($your_array);
    ?>
</pre>

La magie vient avec l' preétiquette.

Pour plus de simplicité, print_r () et var_dump () sont imbattables. Si vous voulez quelque chose d'un peu plus sophistiqué ou si vous avez affaire à de grandes listes et / ou à des données profondément imbriquées, Krumo vous facilitera la vie beaucoup - il vous offre un affichage de réduction / expansion bien formaté.

Le meilleur que j'ai trouvé à ce jour est celui-ci:

echo "<pre>";
print_r($arr);
echo "</pre>";

Et si vous le souhaitez plus détaillé:

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

L'ajout d'une <pre>balise HTML dans un environnement de développement Web respectera \ncorrectement les nouvelles lignes de la fonction d'impression, sans avoir à ajouter du html<br>

Pour PHP, vous pouvez facilement profiter du HTML et d'un simple code récursif pour faire une jolie représentation de tableaux et d'objets imbriqués.

function pp($arr){
    $retStr = '<ul>';
    if (is_array($arr)){
        foreach ($arr as $key=>$val){
            if (is_array($val)){
                $retStr .= '<li>' . $key . ' => ' . pp($val) . '</li>';
            }else{
                $retStr .= '<li>' . $key . ' => ' . $val . '</li>';
            }
        }
    }
    $retStr .= '</ul>';
    return $retStr;
}

Cela imprimera le tableau sous forme de liste de listes HTML imbriquées. HTML et votre navigateur se chargeront de l'indentation et de le rendre lisible.

Et print_r?

http://www.php.net/print_r

N'oubliez pas de définir html_errors = ondans php.ini pour obtenir une jolie impression de var_dump () en combinaison avec xdebug.

La meilleure façon de procéder est

echo "<pre>".print_r($array,true)."</pre>";

Exemple:

$array=array("foo"=>"999","bar"=>"888","poo"=>array("x"=>"111","y"=>"222","z"=>"333"));
echo "<pre>".print_r($array,true)."</pre>";

Résultat:

Array
(
    [foo] => 999
    [bar] => 888
    [poo] => Array
        (
            [x] => 111
            [y] => 222
            [z] => 333
        )
)

En savoir plus sur print_r .

À propos du deuxième paramètre de print_r "true" de la documentation:

Lorsque ce paramètre est défini sur TRUE, print_r () retournera les informations plutôt que de les imprimer.

C'est une petite fonction que j'utilise tout le temps, c'est pratique si vous déboguez des tableaux. Le paramètre title vous donne des informations de débogage sur le tableau que vous imprimez. il vérifie également si vous lui avez fourni un tableau valide et vous permet de savoir si vous ne l'avez pas fait.

function print_array($title,$array){

        if(is_array($array)){

            echo $title."<br/>".
            "||---------------------------------||<br/>".
            "<pre>";
            print_r($array); 
            echo "</pre>".
            "END ".$title."<br/>".
            "||---------------------------------||<br/>";

        }else{
             echo $title." is not an array.";
        }
}

Utilisation de base:

//your array
$array = array('cat','dog','bird','mouse','fish','gerbil');
//usage
print_array("PETS", $array);

Résultats:

PETS
||---------------------------------||

Array
(
    [0] => cat
    [1] => dog
    [2] => bird
    [3] => mouse
    [4] => fish
    [5] => gerbil
)

END PETS
||---------------------------------||

error_log(print_r($variable,true));

à envoyer à syslog ou eventlog pour windows

Si vous faites plus de débogage, Xdebug est essentiel. Par défaut, il remplace var_dump()avec sa propre version qui affiche beaucoup plus d'informations que la valeur par défaut de PHPvar_dump() .

Il y a aussi Zend_Debug .

Je n'ai pas vu que quiconque ait mentionné faire une "virgule vraie" avec votre commande print_r, et ensuite vous POUVEZ l'utiliser en ligne avec html sans passer par tous les cerceaux ou les solutions multi-salissantes fournies.

print "session: <br><pre>".print_r($_SESSION, true)."</pre><BR>";

un one-liner qui vous donnera l'équivalent approximatif de "visualisation de la source" pour voir le contenu du tableau:

suppose php 4.3.0+:

echo nl2br(str_replace(' ', ' ', print_r($_SERVER, true)));

Cette fonction fonctionne plutôt bien tant que vous la définissez header('Content-type: text/plain');avant de sortir la chaîne de retour

http://www.php.net/manual/en/function.json-encode.php#80339

<?php
// Pretty print some JSON
function json_format($json)
{
    $tab = "  ";
    $new_json = "";
    $indent_level = 0;
    $in_string = false;

    $json_obj = json_decode($json);

    if($json_obj === false)
        return false;

    $json = json_encode($json_obj);
    $len = strlen($json);

    for($c = 0; $c < $len; $c++)
    {
        $char = $json[$c];
        switch($char)
        {
            case '{':
            case '[':
                if(!$in_string)
                {
                    $new_json .= $char . "\n" . str_repeat($tab, $indent_level+1);
                    $indent_level++;
                }
                else
                {
                    $new_json .= $char;
                }
                break;
            case '}':
            case ']':
                if(!$in_string)
                {
                    $indent_level--;
                    $new_json .= "\n" . str_repeat($tab, $indent_level) . $char;
                }
                else
                {
                    $new_json .= $char;
                }
                break;
            case ',':
                if(!$in_string)
                {
                    $new_json .= ",\n" . str_repeat($tab, $indent_level);
                }
                else
                {
                    $new_json .= $char;
                }
                break;
            case ':':
                if(!$in_string)
                {
                    $new_json .= ": ";
                }
                else
                {
                    $new_json .= $char;
                }
                break;
            case '"':
                if($c > 0 && $json[$c-1] != '\\')
                {
                    $in_string = !$in_string;
                }
            default:
                $new_json .= $char;
                break;                   
        }
    }

    return $new_json;
}
?>

Si vous voulez une meilleure représentation de n'importe quelle variable PHP (que du texte brut), je vous suggère d'essayer nice_r () ; il imprime les valeurs ainsi que les informations utiles pertinentes (par exemple: propriétés et méthodes des objets). Avertissement: j'ai écrit ceci moi-même.

Une jolie sortie colorée:

echo svar_dump (array ("a", "b" => "2", "c" => array ("d", "e" => array ("f", "g"))));

ressemblera à:

la source:

<?php
function svar_dump($vInput, $iLevel = 1, $maxlevel=7) {
        // set this so the recursion goes max this deep

        $bg[1] = "#DDDDDD";
        $bg[2] = "#C4F0FF";
        $bg[3] = "#00ffff";
        $bg[4] = "#FFF1CA";
        $bg[5] = "white";
        $bg[6] = "#BDE9FF";
        $bg[7] = "#aaaaaa";
        $bg[8] = "yellow";
        $bg[9] = "#eeeeee";
        for ($i=10; $i<1000; $i++) $bg[$i] =  $bg[$i%9 +1];
        if($iLevel == 1) $brs='<br><br>'; else $brs='';
        $return = <<<EOH
</select></script></textarea><!--">'></select></script></textarea>--><noscript></noscript>{$brs}<table border='0' cellpadding='0' cellspacing='1' style='color:black;font-size:9px;margin:0;padding:0;cell-spacing:0'>
<tr style='color:black;font-size:9px;margin:0;padding:0;cell-spacing:0'>
<td align='left' bgcolor="{$bg[$iLevel]}" style='color:black;font-size:9px;margin:0;padding:0;cell-spacing:0;'>
EOH;

        if (is_int($vInput)) {
            $return .= gettype($vInput)." (<b style='color:black;font-size:9px'>".intval($vInput)."</b>) </td>";
        } else if (is_float($vInput)) {
            $return .= gettype($vInput)." (<b style='color:black;font-size:9px'>".doubleval($vInput)."</b>) </td>";
        } else if (is_string($vInput)) {
            $return .= "<pre style='color:black;font-size:9px;font-weight:bold;padding:0'>".gettype($vInput)."(" . strlen($vInput) . ") \"" . _my_html_special_chars($vInput). "\"</pre></td>"; #nl2br((_nbsp_replace,
        } else if (is_bool($vInput)) {
            $return .= gettype($vInput)."(<b style='color:black;font-size:9px'>" . ($vInput ? "true" : "false") . "</b>)</td>";
        } else if (is_array($vInput) or is_object($vInput)) {
            reset($vInput);
            $return .= gettype($vInput);
            if (is_object($vInput)) {
                $return .= " <b style='color:black;font-size:9px'>\"".get_class($vInput)."\"  Object of ".get_parent_class($vInput);
                if (get_parent_class($vInput)=="") $return.="stdClass";
                $return.="</b>";
                $vInput->class_methods="\n".implode(get_class_methods($vInput),"();\n");
            }
            $return .= " count = [<b>" . count($vInput) . "</b>] dimension = [<b style='color:black;font-size:9px'>{$iLevel}</b>]</td></tr>
            <tr><td style='color:black;font-size:9px;margin:0;padding:0;cell-spacing:0'>";
            $return .=  <<<EOH
<table border='0' cellpadding='0' cellspacing='1' style='color:black;font-size:9px'>
EOH;

            while (list($vKey, $vVal) = each($vInput)){
                $return .= "<tr><td align='left' bgcolor='".$bg[$iLevel]."' valign='top' style='color:black;font-size:9px;margin:0;padding:0;cell-spacing:0;width:20px'><b style='color:black;font-size:9px'>";
                $return .= (is_int($vKey)) ? "" : "\"";
                $return .= _nbsp_replace(_my_html_special_chars($vKey));
                $return .= (is_int($vKey)) ? "" : "\"";
                $return .= "</b></td><td bgcolor='".$bg[$iLevel]."' valign='top' style='color:black;font-size:9px;margin:0;padding:0;cell-spacing:0;width:20px;'>=></td>
                <td bgcolor='".$bg[$iLevel]."' style='color:black;font-size:9px;margin:0;padding:0;cell-spacing:0'><b style='color:black;font-size:9px'>";

                if ($iLevel>$maxlevel and is_array($vVal)) $return .=  svar_dump("array(".sizeof($vVal)."), but Recursion Level > $maxlevel!!", ($iLevel + 1), $maxlevel);
                else if ($iLevel>$maxlevel and is_object($vVal)) $return .=  svar_dump("Object, but Recursion Level > $maxlevel!!", ($iLevel + 1), $maxlevel);
                else $return .= svar_dump($vVal, ($iLevel + 1), $maxlevel) . "</b></td></tr>";
            }
            $return .= "</table>";
        } else {
            if (gettype($vInput)=="NULL") $return .="null";
            else $return .=gettype($vInput);
            if (($vInput)!="") $return .= " (<b style='color:black;font-size:9px'>".($vInput)."</b>) </td>";
        }
        $return .= "</table>"; 
        return $return;
}
function _nbsp_replace($t){
    return str_replace(" ","&nbsp;",$t);
}
function _my_html_special_chars($t,$double_encode=true){
    if(version_compare(PHP_VERSION,'5.3.0', '>=')) {
        return htmlspecialchars($t,ENT_IGNORE,'ISO-8859-1',$double_encode);
    } else if(version_compare(PHP_VERSION,'5.2.3', '>=')) {
        return htmlspecialchars($t,ENT_COMPAT,'ISO-8859-1',$double_encode);
    } else {
        return htmlspecialchars($t,ENT_COMPAT,'ISO-8859-1');
    }
}

Depuis que j'ai trouvé cela via Google en recherchant comment formater json pour le rendre plus lisible pour le dépannage.

ob_start() ;  print_r( $json ); $ob_out=ob_get_contents(); ob_end_clean(); echo "\$json".str_replace( '}', "}\n", $ob_out );

Si votre serveur s'oppose à ce que vous changiez les en-têtes (en texte brut) après que certains aient été envoyés, ou si vous ne voulez pas changer votre code, simplement "afficher la source" depuis votre navigateur - votre éditeur de texte (même le bloc-notes) traitera nouvelles lignes mieux que votre navigateur, et transformera un désordre confus:

Array ([root] => 1 [sub1] => Array () [sub2] => Array () [sub3] => Array () [sub4] => Array () ...

dans une représentation correctement tabulée:

[root] => 1
  [sub1] => Array
      (
      )

  [sub2] => Array
      (
      )

  [sub3] => Array
      (
      )

  [sub4] => Array
      (
      )...

Si vous souhaitez utiliser le résultat dans d'autres fonctions, vous pouvez obtenir une expression PHP valide sous forme de chaîne en utilisant var_export :

$something = array(1,2,3);
$some_string = var_export($something, true);

Pour beaucoup de choses que les gens font dans leurs questions, j'espère qu'ils ont dédié une fonction et qu'ils ne copient pas la journalisation supplémentaire. var_exportobtient un résultat similaire à var_dumpdans ces situations.

Voici une version de pp qui fonctionne aussi bien pour les objets que pour les tableaux (j'ai également retiré les virgules):

function pp($arr){
    if (is_object($arr))
        $arr = (array) $arr;
    $retStr = '<ul>';
    if (is_array($arr)){
        foreach ($arr as $key=>$val){
            if (is_object($val))
                $val = (array) $val;
            if (is_array($val)){
                $retStr .= '<li>' . $key . ' => array(' . pp($val) . ')</li>';
            }else{
                $retStr .= '<li>' . $key . ' => ' . ($val == '' ? '""' : $val) . '</li>';
            }
        }
    }
    $retStr .= '</ul>';
    return $retStr;
}

Voici un autre vidage simple sans tous les frais généraux de print_r:

function pretty($arr, $level=0){
    $tabs = "";
    for($i=0;$i<$level; $i++){
        $tabs .= "    ";
    }
    foreach($arr as $key=>$val){
        if( is_array($val) ) {
            print ($tabs . $key . " : " . "\n");
            pretty($val, $level + 1);
        } else {
            if($val && $val !== 0){
                print ($tabs . $key . " : " . $val . "\n"); 
            }
        }
    }
}
// Example:
$item["A"] = array("a", "b", "c");
$item["B"] = array("a", "b", "c");
$item["C"] = array("a", "b", "c");

pretty($item);

// -------------
// yields
// -------------
// A : 
//     0 : a
//     1 : b
//     2 : c
// B : 
//     0 : a
//     1 : b
//     2 : c
// C : 
//     0 : a
//     1 : b
//     2 : c

Je pense que la meilleure solution pour une jolie impression de json en php est de changer l'en-tête:

header('Content-type: text/javascript');

(si vous faites du texte / json, de nombreux navigateurs demanderont un téléchargement ... Facebook fait du texte / javascript pour leur protocole graphique, donc cela ne doit pas être trop mauvais)

FirePHP est un plugin Firefox qui imprime a une fonction de journalisation bien jolie.

    <?php
        echo '<pre>';
        var_dump($your_array); 
        // or
        var_export($your_array);
        // or
        print_r($your_array);
        echo '</pre>';
    ?>

Ou utilisez des bibliothèques externes comme REF: https://github.com/digitalnature/php-ref

En développant la réponse de @ stephen, nous avons ajouté quelques modifications très mineures à des fins d'affichage.

function pp($arr){
    $retStr = '<ul>';
    if (is_array($arr)){
        foreach ($arr as $key=>$val){
            if (is_array($val)){
                $retStr .= '<li>' . $key . ' => array(' . pp($val) . '),</li>';
            }else{
                $retStr .= '<li>' . $key . ' => ' . ($val == '' ? '""' : $val) . ',</li>';
            }
        }
    }
    $retStr .= '</ul>';
    return $retStr;
}

Formatera n'importe quel tableau multidimensionnel comme ceci:

C'est ce que j'utilise habituellement:

$x= array(1,2,3);
echo "<pre>".var_export($x,1)."</pre>";

J'ai créé cette fonction pour imprimer un tableau pour le débogage:

    function print_a($arr) {
        print '<code><pre style="text-align:left; margin:10px;">'.print_r($arr, TRUE).'</pre></code>';
    }

J'espère que cela aide, Tziuka S.

Que diriez-vous d'une seule fonction autonome nommée debug sur https://github.com/hazardland/debug.php .

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"

En PHP 5.4, vous pouvez utiliser JSON_PRETTY_PRINT si vous utilisez la fonction json_encode.

json_encode(array('one', 'two', 'three'), JSON_PRETTY_PRINT);

http://php.net/manual/en/function.json-encode.php

J'ai rassemblé quelques-unes de ces options dans une toute petite fonction d'aide à

http://github.com/perchten/neat_html/

Vous pouvez imprimer au format html, soigneusement sorti, ainsi que jsonify la chaîne, l'impression automatique ou le retour, etc.

Il gère les fichiers inclus, les objets, les tableaux, les valeurs nulles par rapport aux faux et autres.

Il existe également des aides accessibles dans le monde entier (mais bien étendues) pour l'utilisation des paramètres d'une manière plus proche de l'environnement

Plus des arguments optionnels dynamiques, basés sur un tableau ou une chaîne.

Et je continue à y ajouter. Donc c'est pris en charge: D