JSON com impressão bonita com PHP


588

Estou criando um script PHP que alimenta dados JSON para outro script. Meu script cria dados em uma grande matriz associativa e, em seguida, gera os dados usando json_encode. Aqui está um exemplo de script:

$data = array('a' => 'apple', 'b' => 'banana', 'c' => 'catnip');
header('Content-type: text/javascript');
echo json_encode($data);

O código acima produz a seguinte saída:

{"a":"apple","b":"banana","c":"catnip"}

Isso é ótimo se você tiver uma pequena quantidade de dados, mas eu preferiria algo nesse sentido:

{
    "a": "apple",
    "b": "banana",
    "c": "catnip"
}

Existe uma maneira de fazer isso no PHP sem um truque feio? Parece que alguém no Facebook descobriu isso.


26
Para PHP antes da versão 5.4, você pode usar o fallback no upgradephp comoup_json_encode($data, JSON_PRETTY_PRINT);
mario

6
uso do cabeçalho ('Content-Type: application / json'); torna o navegador bastante impresso
partho 23/03

4
A partir de Juy 2018, apenas enviando o Content-Type: application/jsoncabeçalho, o Firefox mostrará o resultado usando seu próprio analisador JSON interno, enquanto o Chrome exibirá o texto sem formatação. +1 Firefox!
andreszs

Respostas:


1127

O PHP 5.4 oferece a JSON_PRETTY_PRINTopção de uso com a json_encode()chamada.

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

<?php
...
$json_string = json_encode($data, JSON_PRETTY_PRINT);

33
Obrigado, esta é a melhor maneira de fazer isso agora. Eu não tinha php 5.4 de volta quando eu fiz esta pergunta embora ...
Zach Rattner

9
5.5.3 aqui, parece adicionar um pouco de espaçamento entre os caracteres, e não um recuo real.

35
JSON não deve conter quebras de linha HTML, enquanto caracteres de nova linha são válidos em JSON. Se você deseja exibir o JSON em uma página da Web, faça uma substituição de sequência nos caracteres de nova linha ou coloque o JSON em um elemento <pre> ... </pre>. Veja json.org para a referência de sintaxe.
Ekillaby

13
Não se esqueça de resposta conjunto Content-Typepara application/jsonse você quiser navegador para exibir JSON bem-impresso bem.
Pijusn 27/11/2015

6
@countfloortiles ele não vai trabalhar diretamente você precisa colocar sua saída na <pre>tag como<?php ... $json_string = json_encode($data, JSON_PRETTY_PRINT); echo "<pre>".$json_string."<pre>";
Salman Mohammad

187

Essa função pega a string JSON e a recorta muito legível. Também deve ser convergente,

prettyPrint( $json ) === prettyPrint( prettyPrint( $json ) )

Entrada

{"key1":[1,2,3],"key2":"value"}

Resultado

{
    "key1": [
        1,
        2,
        3
    ],
    "key2": "value"
}

Código

function prettyPrint( $json )
{
    $result = '';
    $level = 0;
    $in_quotes = false;
    $in_escape = false;
    $ends_line_level = NULL;
    $json_length = strlen( $json );

    for( $i = 0; $i < $json_length; $i++ ) {
        $char = $json[$i];
        $new_line_level = NULL;
        $post = "";
        if( $ends_line_level !== NULL ) {
            $new_line_level = $ends_line_level;
            $ends_line_level = NULL;
        }
        if ( $in_escape ) {
            $in_escape = false;
        } else if( $char === '"' ) {
            $in_quotes = !$in_quotes;
        } else if( ! $in_quotes ) {
            switch( $char ) {
                case '}': case ']':
                    $level--;
                    $ends_line_level = NULL;
                    $new_line_level = $level;
                    break;

                case '{': case '[':
                    $level++;
                case ',':
                    $ends_line_level = $level;
                    break;

                case ':':
                    $post = " ";
                    break;

                case " ": case "\t": case "\n": case "\r":
                    $char = "";
                    $ends_line_level = $new_line_level;
                    $new_line_level = NULL;
                    break;
            }
        } else if ( $char === '\\' ) {
            $in_escape = true;
        }
        if( $new_line_level !== NULL ) {
            $result .= "\n".str_repeat( "\t", $new_line_level );
        }
        $result .= $char.$post;
    }

    return $result;
}

84

Muitos usuários sugeriram que você use

echo json_encode($results, JSON_PRETTY_PRINT);

O que é absolutamente certo. Mas não basta, o navegador precisa entender o tipo de dados, você pode especificar o cabeçalho antes de repetir os dados para o usuário.

header('Content-Type: application/json');

Isso resultará em uma saída bem formatada.

Ou, se você gosta de extensões, pode usar o JSONView for Chrome.


3
Defina apenas o cabeçalho e o Firefox o mostrará perfeitamente usando seu próprio analisador de depuração JSON interno, sem necessidade de tocar no conteúdo JSON! Obrigado!!
andreszs

1
também funciona no chrome. obrigado.
Don Dilanga 7/01

41

Eu tive o mesmo problema.

Enfim, eu apenas usei o código de formatação json aqui:

http://recursive-design.com/blog/2008/03/11/format-json-with-php/

Funciona bem para o que eu precisava.

E uma versão mais mantida: https://github.com/GerHobbelt/nicejson-php


Eu tentei o github.com/GerHobbelt/nicejson-php e funciona muito bem no PHP 5.3.
O contrato do Prof. Falken violou

1
Se você está no PHP7.0 (e acima) e ainda precisa imprimir JSON com indentação personalizada, localheinz.com/blog/2018/01/04/… deve ajudar.
localheinz

40

Percebo que esta pergunta está perguntando sobre como codificar uma matriz associativa para uma string JSON bastante formatada, para que isso não responda diretamente à pergunta, mas se você tiver uma string que já esteja no formato JSON, poderá torná-la bem simples decodificando e recodificando (requer PHP> = 5.4):

$json = json_encode(json_decode($json), JSON_PRETTY_PRINT);

Exemplo:

header('Content-Type: application/json');
$json_ugly = '{"a":1,"b":2,"c":3,"d":4,"e":5}';
$json_pretty = json_encode(json_decode($json_ugly), JSON_PRETTY_PRINT);
echo $json_pretty;

Isso gera:

{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4,
    "e": 5
}

obrigado, só funciona se eu adicionar isso no topo do bloco php ... header ('Content-Type: application / json');
precisa saber é o seguinte

2
@DeyaEldeen Se você não usar esse cabeçalho, o PHP informará ao navegador que ele está enviando HTML; portanto, você deverá visualizar a fonte da página para ver a string JSON formatada. Presumi que isso fosse entendido, mas acho que não. Eu adicionei à minha resposta.
Mike

E qualquer pessoa que esteja seguindo / revisando um log / arquivo no shell unix / linux, esta é a solução aqui! Boa aparência, @Mike, facilita a leitura !.
precisa saber é o seguinte

@ fusion27 Não tenho muita certeza de quais arquivos de log você está se referindo. Eu nunca ouvi falar de nenhum programa que registre algo em JSON.
Mike

@ Mike, é um PHP rápido-e-sujo que instalei anexando o corpo da solicitação (que é uma string JSON serializada) postada no meu PHP em um arquivo de texto, depois o encaixo no shell unix para que eu possa assistir POSTs ao vivo. Estou usando seu truque para formatar esse JSON, tornando o arquivo de texto muito mais utilizável.
precisa saber é o seguinte

25

A colagem de várias respostas se encaixa na minha necessidade de json existente:

Code:
echo "<pre>"; 
echo json_encode(json_decode($json_response), JSON_PRETTY_PRINT); 
echo "</pre>";

Output:
{
    "data": {
        "token_type": "bearer",
        "expires_in": 3628799,
        "scopes": "full_access",
        "created_at": 1540504324
    },
    "errors": [],
    "pagination": {},
    "token_type": "bearer",
    "expires_in": 3628799,
    "scopes": "full_access",
    "created_at": 1540504324
}

3
Aqui está uma pequena função de invólucro para fazer isso:function json_print($json) { return '<pre>' . json_encode(json_decode($json), JSON_PRETTY_PRINT) . '</pre>'; }
Danny Beckett

11

Peguei o código do Composer: https://github.com/composer/composer/blob/master/src/Composer/Json/JsonFile.php e nicejson: https://github.com/GerHobbelt/nicejson-php/blob /master/nicejson.php O código do compositor é bom porque atualiza fluentemente de 5.3 para 5.4, mas codifica apenas o objeto, enquanto o nicejson pega as seqüências de caracteres do json, então eu as juntei. O código pode ser usado para formatar json string e / ou codificar objetos, atualmente o estou usando em um módulo Drupal.

if (!defined('JSON_UNESCAPED_SLASHES'))
    define('JSON_UNESCAPED_SLASHES', 64);
if (!defined('JSON_PRETTY_PRINT'))
    define('JSON_PRETTY_PRINT', 128);
if (!defined('JSON_UNESCAPED_UNICODE'))
    define('JSON_UNESCAPED_UNICODE', 256);

function _json_encode($data, $options = 448)
{
    if (version_compare(PHP_VERSION, '5.4', '>='))
    {
        return json_encode($data, $options);
    }

    return _json_format(json_encode($data), $options);
}

function _pretty_print_json($json)
{
    return _json_format($json, JSON_PRETTY_PRINT);
}

function _json_format($json, $options = 448)
{
    $prettyPrint = (bool) ($options & JSON_PRETTY_PRINT);
    $unescapeUnicode = (bool) ($options & JSON_UNESCAPED_UNICODE);
    $unescapeSlashes = (bool) ($options & JSON_UNESCAPED_SLASHES);

    if (!$prettyPrint && !$unescapeUnicode && !$unescapeSlashes)
    {
        return $json;
    }

    $result = '';
    $pos = 0;
    $strLen = strlen($json);
    $indentStr = ' ';
    $newLine = "\n";
    $outOfQuotes = true;
    $buffer = '';
    $noescape = true;

    for ($i = 0; $i < $strLen; $i++)
    {
        // Grab the next character in the string
        $char = substr($json, $i, 1);

        // Are we inside a quoted string?
        if ('"' === $char && $noescape)
        {
            $outOfQuotes = !$outOfQuotes;
        }

        if (!$outOfQuotes)
        {
            $buffer .= $char;
            $noescape = '\\' === $char ? !$noescape : true;
            continue;
        }
        elseif ('' !== $buffer)
        {
            if ($unescapeSlashes)
            {
                $buffer = str_replace('\\/', '/', $buffer);
            }

            if ($unescapeUnicode && function_exists('mb_convert_encoding'))
            {
                // http://stackoverflow.com/questions/2934563/how-to-decode-unicode-escape-sequences-like-u00ed-to-proper-utf-8-encoded-cha
                $buffer = preg_replace_callback('/\\\\u([0-9a-f]{4})/i',
                    function ($match)
                    {
                        return mb_convert_encoding(pack('H*', $match[1]), 'UTF-8', 'UCS-2BE');
                    }, $buffer);
            } 

            $result .= $buffer . $char;
            $buffer = '';
            continue;
        }
        elseif(false !== strpos(" \t\r\n", $char))
        {
            continue;
        }

        if (':' === $char)
        {
            // Add a space after the : character
            $char .= ' ';
        }
        elseif (('}' === $char || ']' === $char))
        {
            $pos--;
            $prevChar = substr($json, $i - 1, 1);

            if ('{' !== $prevChar && '[' !== $prevChar)
            {
                // If this character is the end of an element,
                // output a new line and indent the next line
                $result .= $newLine;
                for ($j = 0; $j < $pos; $j++)
                {
                    $result .= $indentStr;
                }
            }
            else
            {
                // Collapse empty {} and []
                $result = rtrim($result) . "\n\n" . $indentStr;
            }
        }

        $result .= $char;

        // If the last character was the beginning of an element,
        // output a new line and indent the next line
        if (',' === $char || '{' === $char || '[' === $char)
        {
            $result .= $newLine;

            if ('{' === $char || '[' === $char)
            {
                $pos++;
            }

            for ($j = 0; $j < $pos; $j++)
            {
                $result .= $indentStr;
            }
        }
    }
    // If buffer not empty after formating we have an unclosed quote
    if (strlen($buffer) > 0)
    {
        //json is incorrectly formatted
        $result = false;
    }

    return $result;
}

Assim que se faz! A implementação própria é executada apenas se o nativo não estiver disponível. Se você tem certeza de que seu código será executado apenas no PHP 5.4 ou superior, você pode descansar em JSON_PRETTY_PRINT
Heroselohim

Esta solução me fornece erro (Erro de análise: erro de sintaxe, T_FUNCTION inesperado) na função de linha ($ match)
ARLabs


10

Se você estiver no firefox, instale o JSONovich . Não é realmente uma solução PHP que eu conheço, mas faz o truque para fins de desenvolvimento / depuração.


3
Eu acho que esta é a solução adequada para quando criar uma API. Dá o melhor dos dois mundos, fácil depuração, pois você pode ler tudo e não está alterando o comportamento de back-end, incluindo seu desempenho.
Daniel

Concordado, é bem formatado com cores e dobrável também. Muito melhor do que você poderia esperar conseguir com um pouco de PHP
Matthew Bloqueio

10

Eu usei isso:

echo "<pre>".json_encode($response, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)."</pre>";

Ou use os cabeçalhos php como abaixo:

header('Content-type: application/json; charset=UTF-8');
echo json_encode($response, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);

8

Maneira simples para php> 5.4: como no gráfico do Facebook

$Data = array('a' => 'apple', 'b' => 'banana', 'c' => 'catnip');
$json= json_encode($Data, JSON_PRETTY_PRINT);
header('Content-Type: application/json');
print_r($json);

Resultado no navegador

{
    "a": "apple",
    "b": "banana",
    "c": "catnip"
}

@ Madbreaks, ele imprime bem no arquivo php, não precisa escrever no arquivo json, assim como no facebook.
dknepa

6

Use <pre>em combinação com json_encode()e a JSON_PRETTY_PRINTopção:

<pre>
    <?php
    echo json_encode($dataArray, JSON_PRETTY_PRINT);
    ?>
</pre>

6

Se você já possui JSON ( $ugly_json)

echo nl2br(str_replace(' ', '&nbsp;', (json_encode(json_decode($ugly_json), JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES))));

5

Saída colorida total: Solução minúscula

Código:

$s = '{"access": {"token": {"issued_at": "2008-08-16T14:10:31.309353", "expires": "2008-08-17T14:10:31Z", "id": "MIICQgYJKoZIhvcIegeyJpc3N1ZWRfYXQiOiAi"}, "serviceCatalog": [], "user": {"username": "ajay", "roles_links": [], "id": "16452ca89", "roles": [], "name": "ajay"}}}';

$crl = 0;
$ss = false;
echo "<pre>";
for($c=0; $c<strlen($s); $c++)
{
    if ( $s[$c] == '}' || $s[$c] == ']' )
    {
        $crl--;
        echo "\n";
        echo str_repeat(' ', ($crl*2));
    }
    if ( $s[$c] == '"' && ($s[$c-1] == ',' || $s[$c-2] == ',') )
    {
        echo "\n";
        echo str_repeat(' ', ($crl*2));
    }
    if ( $s[$c] == '"' && !$ss )
    {
        if ( $s[$c-1] == ':' || $s[$c-2] == ':' )
            echo '<span style="color:#0000ff;">';
        else
            echo '<span style="color:#ff0000;">';
    }
    echo $s[$c];
    if ( $s[$c] == '"' && $ss )
        echo '</span>';
    if ( $s[$c] == '"' )
          $ss = !$ss;
    if ( $s[$c] == '{' || $s[$c] == '[' )
    {
        $crl++;
        echo "\n";
        echo str_repeat(' ', ($crl*2));
    }
}
echo $s[$c];

isso foi muito útil, mesmo com alguns erros. Eu os consertei e agora funciona como um encanto, e a função não é tão grande assim! Obrigado Ajay
Daniel

apenas para comentar as correções, se alguém quiser usar isso ... adicione uma verificação de validação $ c> 1 na segunda e terceira condições, e o último eco envolva-o em um is_array ($ s) se. isso deve cobri-lo e você não deve receber nenhum erro de deslocamento de cadeia não inicializado.
Daniel

5

Você pode modificar um pouco a resposta de Kendall Hopkins na instrução switch para obter uma impressão bem limpa e bem identificada, passando uma string json para o seguinte:

function prettyPrint( $json ){

$result = '';
$level = 0;
$in_quotes = false;
$in_escape = false;
$ends_line_level = NULL;
$json_length = strlen( $json );

for( $i = 0; $i < $json_length; $i++ ) {
    $char = $json[$i];
    $new_line_level = NULL;
    $post = "";
    if( $ends_line_level !== NULL ) {
        $new_line_level = $ends_line_level;
        $ends_line_level = NULL;
    }
    if ( $in_escape ) {
        $in_escape = false;
    } else if( $char === '"' ) {
        $in_quotes = !$in_quotes;
    } else if( ! $in_quotes ) {
        switch( $char ) {
            case '}': case ']':
                $level--;
                $ends_line_level = NULL;
                $new_line_level = $level;
                $char.="<br>";
                for($index=0;$index<$level-1;$index++){$char.="-----";}
                break;

            case '{': case '[':
                $level++;
                $char.="<br>";
                for($index=0;$index<$level;$index++){$char.="-----";}
                break;
            case ',':
                $ends_line_level = $level;
                $char.="<br>";
                for($index=0;$index<$level;$index++){$char.="-----";}
                break;

            case ':':
                $post = " ";
                break;

            case "\t": case "\n": case "\r":
                $char = "";
                $ends_line_level = $new_line_level;
                $new_line_level = NULL;
                break;
        }
    } else if ( $char === '\\' ) {
        $in_escape = true;
    }
    if( $new_line_level !== NULL ) {
        $result .= "\n".str_repeat( "\t", $new_line_level );
    }
    $result .= $char.$post;
}

echo "RESULTS ARE: <br><br>$result";
return $result;

}

Agora basta executar a função prettyPrint ($ your_json_string); inline no seu php e aproveite a impressão. Se você é um minimalista e não fazer como suportes para alguma razão, você pode se livrar daqueles facilmente substituindo o $char.="<br>";com $char="<br>";no top três casos de switch on $ caractere. Veja o que você recebe para uma chamada da API do Google Maps para a cidade de Calgary

RESULTS ARE: 

{
- - - "results" : [
- - -- - - {
- - -- - -- - - "address_components" : [
- - -- - -- - -- - - {
- - -- - -- - -- - -- - - "long_name" : "Calgary"
- - -- - -- - -- - -- - - "short_name" : "Calgary"
- - -- - -- - -- - -- - - "types" : [
- - -- - -- - -- - -- - -- - - "locality"
- - -- - -- - -- - -- - -- - - "political" ]
- - -- - -- - -- - - }
- - -- - -- - -
- - -- - -- - -- - - {
- - -- - -- - -- - -- - - "long_name" : "Division No. 6"
- - -- - -- - -- - -- - - "short_name" : "Division No. 6"
- - -- - -- - -- - -- - - "types" : [
- - -- - -- - -- - -- - -- - - "administrative_area_level_2"
- - -- - -- - -- - -- - -- - - "political" ]
- - -- - -- - -- - - }
- - -- - -- - -
- - -- - -- - -- - - {
- - -- - -- - -- - -- - - "long_name" : "Alberta"
- - -- - -- - -- - -- - - "short_name" : "AB"
- - -- - -- - -- - -- - - "types" : [
- - -- - -- - -- - -- - -- - - "administrative_area_level_1"
- - -- - -- - -- - -- - -- - - "political" ]
- - -- - -- - -- - - }
- - -- - -- - -
- - -- - -- - -- - - {
- - -- - -- - -- - -- - - "long_name" : "Canada"
- - -- - -- - -- - -- - - "short_name" : "CA"
- - -- - -- - -- - -- - - "types" : [
- - -- - -- - -- - -- - -- - - "country"
- - -- - -- - -- - -- - -- - - "political" ]
- - -- - -- - -- - - }
- - -- - -- - - ]
- - -- - -
- - -- - -- - - "formatted_address" : "Calgary, AB, Canada"
- - -- - -- - - "geometry" : {
- - -- - -- - -- - - "bounds" : {
- - -- - -- - -- - -- - - "northeast" : {
- - -- - -- - -- - -- - -- - - "lat" : 51.18383
- - -- - -- - -- - -- - -- - - "lng" : -113.8769511 }
- - -- - -- - -- - -
- - -- - -- - -- - -- - - "southwest" : {
- - -- - -- - -- - -- - -- - - "lat" : 50.84240399999999
- - -- - -- - -- - -- - -- - - "lng" : -114.27136 }
- - -- - -- - -- - - }
- - -- - -- - -
- - -- - -- - -- - - "location" : {
- - -- - -- - -- - -- - - "lat" : 51.0486151
- - -- - -- - -- - -- - - "lng" : -114.0708459 }
- - -- - -- - -
- - -- - -- - -- - - "location_type" : "APPROXIMATE"
- - -- - -- - -- - - "viewport" : {
- - -- - -- - -- - -- - - "northeast" : {
- - -- - -- - -- - -- - -- - - "lat" : 51.18383
- - -- - -- - -- - -- - -- - - "lng" : -113.8769511 }
- - -- - -- - -- - -
- - -- - -- - -- - -- - - "southwest" : {
- - -- - -- - -- - -- - -- - - "lat" : 50.84240399999999
- - -- - -- - -- - -- - -- - - "lng" : -114.27136 }
- - -- - -- - -- - - }
- - -- - -- - - }
- - -- - -
- - -- - -- - - "place_id" : "ChIJ1T-EnwNwcVMROrZStrE7bSY"
- - -- - -- - - "types" : [
- - -- - -- - -- - - "locality"
- - -- - -- - -- - - "political" ]
- - -- - - }
- - - ]

- - - "status" : "OK" }

Isso é muito bom, obrigado. Uma coisa que eu acho que para adicionar uma ligeira melhoria é usar uma var para: $ indent = "-----" e depois usá-la (em vez de "-----" em diferentes locais do código)
gvanto

3

Você poderia fazê-lo como abaixo.

$array = array(
   "a" => "apple",
   "b" => "banana",
   "c" => "catnip"
);

foreach ($array as $a_key => $a_val) {
   $json .= "\"{$a_key}\" : \"{$a_val}\",\n";
}

header('Content-Type: application/json');
echo "{\n"  .rtrim($json, ",\n") . "\n}";

Acima sairia como o Facebook.

{
"a" : "apple",
"b" : "banana",
"c" : "catnip"
}

E se a_valfor uma matriz ou um objeto?
Zach Rattner

1
Eu respondi um exemplo usando o Json na pergunta, atualizarei minha resposta em breve.
Jake #

3

Caso clássico para uma solução recursiva. Aqui está o meu:

class JsonFormatter {
    public static function prettyPrint(&$j, $indentor = "\t", $indent = "") {
        $inString = $escaped = false;
        $result = $indent;

        if(is_string($j)) {
            $bak = $j;
            $j = str_split(trim($j, '"'));
        }

        while(count($j)) {
            $c = array_shift($j);
            if(false !== strpos("{[,]}", $c)) {
                if($inString) {
                    $result .= $c;
                } else if($c == '{' || $c == '[') {
                    $result .= $c."\n";
                    $result .= self::prettyPrint($j, $indentor, $indentor.$indent);
                    $result .= $indent.array_shift($j);
                } else if($c == '}' || $c == ']') {
                    array_unshift($j, $c);
                    $result .= "\n";
                    return $result;
                } else {
                    $result .= $c."\n".$indent;
                } 
            } else {
                $result .= $c;
                $c == '"' && !$escaped && $inString = !$inString;
                $escaped = $c == '\\' ? !$escaped : false;
            }
        }

        $j = $bak;
        return $result;
    }
}

Uso:

php > require 'JsonFormatter.php';
php > $a = array('foo' => 1, 'bar' => 'This "is" bar', 'baz' => array('a' => 1, 'b' => 2, 'c' => '"3"'));
php > print_r($a);
Array
(
    [foo] => 1
    [bar] => This "is" bar
    [baz] => Array
        (
            [a] => 1
            [b] => 2
            [c] => "3"
        )

)
php > echo JsonFormatter::prettyPrint(json_encode($a));
{
    "foo":1,
    "bar":"This \"is\" bar",
    "baz":{
        "a":1,
        "b":2,
        "c":"\"3\""
    }
}

Felicidades


3

Esta solução torna JSON 'realmente bonito'. Não é exatamente o que o OP estava pedindo, mas permite visualizar melhor o JSON.

/**
 * takes an object parameter and returns the pretty json format.
 * this is a space saving version that uses 2 spaces instead of the regular 4
 *
 * @param $in
 *
 * @return string
 */
function pretty_json ($in): string
{
  return preg_replace_callback('/^ +/m',
    function (array $matches): string
    {
      return str_repeat(' ', strlen($matches[0]) / 2);
    }, json_encode($in, JSON_PRETTY_PRINT | JSON_HEX_APOS)
  );
}

/**
 * takes a JSON string an adds colours to the keys/values
 * if the string is not JSON then it is returned unaltered.
 *
 * @param string $in
 *
 * @return string
 */

function markup_json (string $in): string
{
  $string  = 'green';
  $number  = 'darkorange';
  $null    = 'magenta';
  $key     = 'red';
  $pattern = '/("(\\\\u[a-zA-Z0-9]{4}|\\\\[^u]|[^\\\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/';
  return preg_replace_callback($pattern,
      function (array $matches) use ($string, $number, $null, $key): string
      {
        $match  = $matches[0];
        $colour = $number;
        if (preg_match('/^"/', $match))
        {
          $colour = preg_match('/:$/', $match)
            ? $key
            : $string;
        }
        elseif ($match === 'null')
        {
          $colour = $null;
        }
        return "<span style='color:{$colour}'>{$match}</span>";
      }, str_replace(['<', '>', '&'], ['&lt;', '&gt;', '&amp;'], $in)
   ) ?? $in;
}

public function test_pretty_json_object ()
{
  $ob       = new \stdClass();
  $ob->test = 'unit-tester';
  $json     = pretty_json($ob);
  $expected = <<<JSON
{
  "test": "unit-tester"
}
JSON;
  $this->assertEquals($expected, $json);
}

public function test_pretty_json_str ()
{
  $ob   = 'unit-tester';
  $json = pretty_json($ob);
  $this->assertEquals("\"$ob\"", $json);
}

public function test_markup_json ()
{
  $json = <<<JSON
[{"name":"abc","id":123,"warnings":[],"errors":null},{"name":"abc"}]
JSON;
  $expected = <<<STR
[
  {
    <span style='color:red'>"name":</span> <span style='color:green'>"abc"</span>,
    <span style='color:red'>"id":</span> <span style='color:darkorange'>123</span>,
    <span style='color:red'>"warnings":</span> [],
    <span style='color:red'>"errors":</span> <span style='color:magenta'>null</span>
  },
  {
    <span style='color:red'>"name":</span> <span style='color:green'>"abc"</span>
  }
]
STR;

  $output = markup_json(pretty_json(json_decode($json)));
  $this->assertEquals($expected,$output);
}

}


2

Se você usou apenas $json_string = json_encode($data, JSON_PRETTY_PRINT);, você acessará o navegador da seguinte forma (usando o link do Facebook da pergunta :)): insira a descrição da imagem aqui

mas se você usou uma extensão chrome como JSONView (mesmo sem a opção PHP acima), obtém uma solução depurável mais legível, na qual é possível dobrar / recolher cada objeto JSON com facilidade, assim: insira a descrição da imagem aqui


1

print_r impressão bonita para PHP

Exemplo de PHP

function print_nice($elem,$max_level=10,$print_nice_stack=array()){
    if(is_array($elem) || is_object($elem)){
        if(in_array($elem,$print_nice_stack,true)){
            echo "<font color=red>RECURSION</font>";
            return;
        }
        $print_nice_stack[]=&$elem;
        if($max_level<1){
            echo "<font color=red>nivel maximo alcanzado</font>";
            return;
        }
        $max_level--;
        echo "<table border=1 cellspacing=0 cellpadding=3 width=100%>";
        if(is_array($elem)){
            echo '<tr><td colspan=2 style="background-color:#333333;"><strong><font color=white>ARRAY</font></strong></td></tr>';
        }else{
            echo '<tr><td colspan=2 style="background-color:#333333;"><strong>';
            echo '<font color=white>OBJECT Type: '.get_class($elem).'</font></strong></td></tr>';
        }
        $color=0;
        foreach($elem as $k => $v){
            if($max_level%2){
                $rgb=($color++%2)?"#888888":"#BBBBBB";
            }else{
                $rgb=($color++%2)?"#8888BB":"#BBBBFF";
            }
            echo '<tr><td valign="top" style="width:40px;background-color:'.$rgb.';">';
            echo '<strong>'.$k."</strong></td><td>";
            print_nice($v,$max_level,$print_nice_stack);
            echo "</td></tr>";
        }
        echo "</table>";
        return;
    }
    if($elem === null){
        echo "<font color=green>NULL</font>";
    }elseif($elem === 0){
        echo "0";
    }elseif($elem === true){
        echo "<font color=green>TRUE</font>";
    }elseif($elem === false){
        echo "<font color=green>FALSE</font>";
    }elseif($elem === ""){
        echo "<font color=green>EMPTY STRING</font>";
    }else{
        echo str_replace("\n","<strong><font color=red>*</font></strong><br>\n",$elem);
    }
}

1

1 - json_encode($rows,JSON_PRETTY_PRINT);retorna dados pré-modificados com caracteres de nova linha. Isso é útil para a entrada da linha de comando, mas como você descobriu, não parece tão bonito no navegador. O navegador aceitará as novas linhas como fonte (e, portanto, exibir a fonte da página realmente mostrará o bonito JSON), mas elas não são usadas para formatar a saída nos navegadores. Navegadores requerem HTML.

2 - use este github de função

<?php
    /**
     * Formats a JSON string for pretty printing
     *
     * @param string $json The JSON to make pretty
     * @param bool $html Insert nonbreaking spaces and <br />s for tabs and linebreaks
     * @return string The prettified output
     * @author Jay Roberts
     */
    function _format_json($json, $html = false) {
        $tabcount = 0;
        $result = '';
        $inquote = false;
        $ignorenext = false;
        if ($html) {
            $tab = "&nbsp;&nbsp;&nbsp;&nbsp;";
            $newline = "<br/>";
        } else {
            $tab = "\t";
            $newline = "\n";
        }
        for($i = 0; $i < strlen($json); $i++) {
            $char = $json[$i];
            if ($ignorenext) {
                $result .= $char;
                $ignorenext = false;
            } else {
                switch($char) {
                    case '[':
                    case '{':
                        $tabcount++;
                        $result .= $char . $newline . str_repeat($tab, $tabcount);
                        break;
                    case ']':
                    case '}':
                        $tabcount--;
                        $result = trim($result) . $newline . str_repeat($tab, $tabcount) . $char;
                        break;
                    case ',':
                        $result .= $char . $newline . str_repeat($tab, $tabcount);
                        break;
                    case '"':
                        $inquote = !$inquote;
                        $result .= $char;
                        break;
                    case '\\':
                        if ($inquote) $ignorenext = true;
                        $result .= $char;
                        break;
                    default:
                        $result .= $char;
                }
            }
        }
        return $result;
    }

0

A seguir, o que funcionou para mim:

Conteúdo do test.php:

<html>
<body>
Testing JSON array output
  <pre>
  <?php
  $data = array('a'=>'apple', 'b'=>'banana', 'c'=>'catnip');
  // encode in json format 
  $data = json_encode($data);

  // json as single line
  echo "</br>Json as single line </br>";
  echo $data;
  // json as an array, formatted nicely
  echo "</br>Json as multiline array </br>";
  print_r(json_decode($data, true));
  ?>
  </pre>
</body>
</html>

resultado:

Testing JSON array output


Json as single line 
{"a":"apple","b":"banana","c":"catnip"}
Json as multiline array 
Array
(
    [a] => apple
    [b] => banana
    [c] => catnip
)

Observe também o uso da tag "pre" em html.

Espero que ajude alguém


2
Isso não responde à pergunta. Você está descartando vars, não imprimindo JSON formatado.
Madbreaks

0

a melhor maneira de formatar dados JSON é assim!

header('Content-type: application/json; charset=UTF-8');
echo json_encode($response, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);

Substitua $ response pelos seus dados, que devem ser convertidos em JSON


0

Para aqueles que executam o PHP versão 5.3 ou anterior, você pode tentar abaixo:

$pretty_json = "<pre>".print_r(json_decode($json), true)."</pre>";

echo $pretty_json;

-4

Se você estiver trabalhando com MVC

tente fazer isso no seu controlador

public function getLatestUsers() {
    header('Content-Type: application/json');
    echo $this->model->getLatestUsers(); // this returns json_encode($somedata, JSON_PRETTY_PRINT)
}

se você chamar / getLatestUsers, obterá uma saída JSON bonita;)


ver meu comentário após o eco, onde ele está sendo muito printend
webmaster

1
MVC é um tipo de design de estrutura, nada a ver com a saída de JSON.
Maciej Paprocki

é uma resposta de 2013 pessoas;)
webmaster
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.