Existe uma impressão bonita para PHP?

Estou consertando alguns scripts PHP e sinto falta da bonita impressora de Ruby. ie

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

irá gerar {: one => 1}. Isso funciona até mesmo com objetos bastante complexos e torna muito mais fácil cavar em um script desconhecido. Existe alguma maneira de duplicar essa funcionalidade no PHP?

Ambos print_r()e var_dump()produzirão representações visuais de objetos dentro do PHP.

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

Isso é o que eu uso para imprimir meus arrays:

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

A magia vem com a preetiqueta.

Para simplificar, print_r () e var_dump () não podem ser batidos. Se você quer algo um pouco mais elaborado ou está lidando com listas grandes e / ou dados profundamente aninhados, o Krumo tornará sua vida muito mais fácil - ele fornece a você uma tela de recolhimento / expansão bem formatada.

O melhor que encontrei até agora é este:

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

E se você quiser mais detalhado:

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

Adicionar uma <pre>tag HTML em um ambiente de desenvolvimento web respeitará as novas linhas \nda função de impressão corretamente, sem ter que adicionar algum html<br>

Para PHP, você pode facilmente tirar proveito do HTML e de alguns códigos recursivos simples para fazer uma representação bonita de arrays e objetos aninhados.

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

Isso imprimirá a matriz como uma lista de listas HTML aninhadas. O HTML e seu navegador cuidarão de recuar e torná-lo legível.

Que tal print_r?

http://www.php.net/print_r

Lembre-se de definir html_errors = onno php.ini para obter uma impressão bonita de var_dump () em combinação com xdebug.

A melhor maneira de fazer isso é

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

Exemplo:

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

Resultado:

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

Leia mais sobre print_r .

Sobre o segundo parâmetro de print_r "true" da documentação:

Quando este parâmetro é definido como TRUE, print_r () irá retornar a informação ao invés de imprimi-la.

Esta é uma pequena função que eu uso o tempo todo, é útil se você estiver depurando arrays. O parâmetro title fornece algumas informações de depuração como o array que você está imprimindo. ele também verifica se você o forneceu com um array válido e permite que você saiba se não o fez.

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

Uso básico:

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

Resultados:

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

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

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

error_log(print_r($variable,true));

para enviar para syslog ou log de eventos para janelas

Se você estiver fazendo mais depuração, o Xdebug é essencial. Por padrão, ele é substituído var_dump()por sua própria versão, que exibe muito mais informações do que o padrão do PHPvar_dump() .

Também existe o Zend_Debug .

Eu não vi que alguém mencionou fazer uma "vírgula verdadeira" com o comando print_r, e então você PODE usá-lo inline com html sem passar por todos os obstáculos ou soluções de aparência multi-bagunçadas fornecidas.

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

um one-liner que lhe dará o equivalente aproximado de "visualização da fonte" para ver o conteúdo do array:

assume php 4.3.0+:

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

Esta função funciona muito bem desde que você defina header('Content-type: text/plain');antes de enviar a string de retorno

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

Se você quiser uma representação mais agradável de qualquer variável do PHP (do que apenas texto simples), sugiro que tente nice_r () ; ele imprime valores mais informações úteis relevantes (por exemplo: propriedades e métodos para objetos). Disclaimer: Eu mesmo escrevi isso.

Uma bela saída colorida:

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

será semelhante a:

fonte:

<?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');
    }
}

Já que eu encontrei isso no google procurando por como formatar json para torná-lo mais legível para solução de problemas.

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

Se o seu servidor objetar que você altere os cabeçalhos (para texto simples) após alguns terem sido enviados, ou se você não quiser alterar o seu código, apenas "veja o código-fonte" do seu navegador - o seu editor de texto (até mesmo o bloco de notas) irá processar novas linhas melhores do que o seu navegador e vão virar uma bagunça confusa

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

em uma representação devidamente tabulada:

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

  [sub2] => Array
      (
      )

  [sub3] => Array
      (
      )

  [sub4] => Array
      (
      )...

Se você deseja usar o resultado em outras funções, pode obter uma expressão PHP válida como uma string usando var_export :

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

Para muitas coisas que as pessoas estão fazendo em suas perguntas, espero que tenham dedicado uma função e não copiem e colem o registro extra. var_exportobtém uma saída semelhante a var_dumpnessas situações.

Aqui está uma versão do pp que funciona para objetos e também para matrizes (também tirei as vírgulas):

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

Aqui está outro despejo simples sem toda a sobrecarga 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

Acho que a melhor solução para imprimir bastante json em php é alterar o cabeçalho:

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

(se você usar text / json, muitos navegadores solicitarão um download ... o Facebook usa text / javascript para seu protocolo gráfico, então não deve ser tão ruim)

FirePHP é um plugin do firefox que imprime um recurso de registro muito bonito.

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

Ou use bibliotecas externas como REF: https://github.com/digitalnature/php-ref

Expandindo a resposta de @stephen, alguns ajustes menores foram adicionados para fins de exibição.

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

Formatará qualquer matriz multidimensional da seguinte forma:

Isso é o que eu costumo usar:

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

Fiz esta função para imprimir uma matriz para depuração:

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

Espero que ajude, Tziuka S.

Que tal uma única função autônoma chamada de depuração de https://github.com/hazardland/debug.php .

A saída html debug () típica tem esta aparência:

Mas você pode gerar dados como um texto simples com a mesma função também (com 4 guias de espaço recuado) como este (e até mesmo registrá-lo no arquivo, se necessário):

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"

No PHP 5.4, você pode usar JSON_PRETTY_PRINT se estiver usando a função json_encode.

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

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

Eu reuni algumas dessas opções em uma pequena função auxiliar em

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

Você pode imprimir em html, com saída organizada, bem como jsonificar a string, imprimir automaticamente ou retornar etc.

Ele lida com inclusões de arquivos, objetos, matrizes, nulos vs falsos e assim por diante.

Existem também alguns auxiliares globalmente acessíveis (mas com um escopo bem definido) para quando usar as configurações de uma maneira mais semelhante ao ambiente

Além de argumentos opcionais dinâmicos, baseados em array ou string.

E, eu continuo adicionando a ele. Portanto, é compatível: D