JSON con stampa carina con PHP

589

Sto costruendo uno script PHP che fornisce i dati JSON a un altro script. Il mio script crea i dati in un array associativo di grandi dimensioni e quindi genera i dati utilizzando json_encode. Ecco uno script di esempio:

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

Il codice precedente produce il seguente output:

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

Questo è fantastico se hai una piccola quantità di dati, ma preferirei qualcosa del genere: 

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

C'è un modo per farlo in PHP senza un brutto hack? Sembra che qualcuno su Facebook l'abbia capito.

php  json  pretty-print 
— Zach Rattner
fonte
26
Per PHP prima della 5.4, è possibile utilizzare il fallback in upgradephp comeup_json_encode($data, JSON_PRETTY_PRINT);
— mario
6
uso dell'intestazione ('Content-Type: application / json'); rende il browser piuttosto stampa
— partho
4
A partire da Juy 2018, semplicemente inviando l' Content-Type: application/jsonintestazione Firefox mostrerà il risultato utilizzando il proprio parser JSON interno, mentre Chrome mostra il testo normale. +1 Firefox!
— andreszs

Risposte:

1127

PHP 5.4 offre l' JSON_PRETTY_PRINTopzione per l'uso con la json_encode()chiamata.

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

<?php
...
$json_string = json_encode($data, JSON_PRETTY_PRINT);
— ekillaby
fonte
33
Grazie, questo è il modo migliore per farlo ora. Non avevo php 5.4 quando ho fatto questa domanda però ...
— Zach Rattner
9
5.5.3 qui, sembra solo aggiungere un po 'di spazio tra i personaggi, non alcun rientro effettivo.
35
JSON non dovrebbe contenere interruzioni di riga HTML, mentre i caratteri di nuova riga sono validi in JSON. Se si desidera visualizzare JSON su una pagina Web, eseguire manualmente una sostituzione di stringa sui caratteri di nuova riga oppure inserire JSON in un elemento <pre> ... </pre>. Vedi json.org per il riferimento alla sintassi.
— ekillaby,
13
Non dimenticate di reazione impostata Content-Typeper application/jsonse si vuole browser per visualizzare pretty-stampato JSON bene.
— Pijusn,
6
@countfloortiles non funzionerà direttamente è necessario racchiudere l'output in <pre>tag come<?php ... $json_string = json_encode($data, JSON_PRETTY_PRINT); echo "<pre>".$json_string."<pre>";
— Salman Mohammad
187

Questa funzione prenderà la stringa JSON e la indentificherà in modo molto leggibile. Dovrebbe anche essere convergente,

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

Ingresso

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

Produzione

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

Codice

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;
}
— Kendall Hopkins
fonte
84

Molti utenti ti hanno suggerito di utilizzare

echo json_encode($results, JSON_PRETTY_PRINT);

È assolutamente giusto. Ma non è abbastanza, il browser deve capire il tipo di dati, è possibile specificare l'intestazione appena prima di inviare nuovamente i dati all'utente.

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

Ciò si tradurrà in un output ben formattato.

Oppure, se ti piacciono le estensioni puoi usare JSONView per Chrome.

— Wahib Zakraoui
fonte
3
Imposta solo l'intestazione e Firefox lo mostrerà perfettamente usando il suo parser di debug JSON interno, non c'è bisogno di toccare i contenuti JSON! Grazie!!
— andreszs
1
funziona anche con Chrome. Grazie.
— Don Dilanga,
41

Ho avuto lo stesso problema.

Comunque ho appena usato il codice di formattazione json qui:

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

Funziona bene per quello di cui avevo bisogno.

E una versione più mantenuta: https://github.com/GerHobbelt/nicejson-php

— Jason
fonte
Ho provato github.com/GerHobbelt/nicejson-php e funziona benissimo in PHP 5.3.
— contratto del Prof. Falken è stato violato il
1
Se sei su PHP7.0 (e versioni successive) e hai ancora bisogno di stampare graziosamente JSON con rientro personalizzato, localheinz.com/blog/2018/01/04/… dovrebbe aiutarti.
— localheinz
40

Mi rendo conto che questa domanda si stia chiedendo come codificare un array associativo in una stringa JSON piuttosto formattata, quindi questo non risponde direttamente alla domanda, ma se hai una stringa che è già in formato JSON, puoi farlo abbastanza semplicemente decodificandolo e ricodificandolo (richiede PHP> = 5.4):

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

Esempio:

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;

Questo produce:

{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4,
    "e": 5
}
— Mike
fonte
grazie, funziona solo se lo aggiungo all'inizio del blocco php ... header ('Content-Type: application / json');
— DeyaEldeen,
2
@DeyaEldeen Se non usi quell'intestazione, PHP dirà al browser che sta inviando HTML, quindi dovresti visualizzare l'origine della pagina per vedere la stringa JSON formattata. Ho pensato che fosse compreso, ma credo di no. L'ho aggiunto alla mia risposta.
— Mike,
E chiunque sta seguendo / rivedendo un registro / file nella shell unix / linux, questa è la soluzione qui! Bello guardare, @Mike, rende facile la lettura !.
— fusion27
@ fusion27 Non sono davvero sicuro a quali file di registro ti riferisci. Non ho mai sentito parlare di programmi che registrano qualcosa in JSON.
— Mike,
@ Mike, è un PHP quick-n-dirty che ho montato aggiungendo il corpo della richiesta (che è una stringa JSON serializzata) POSTATO al mio PHP in un file di testo, quindi lo accingo nella shell unix in modo da poter vedere i POST live. Sto usando il tuo trucco per formattare JSON rendendo il file di testo molto più utilizzabile.
— fusion27,
25

Incollare diverse risposte insieme corrisponde al mio bisogno di json esistente:

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
}
— Kevin
fonte
3
Ecco una piccola funzione wrapper per fare questo:function json_print($json) { return '<pre>' . json_encode(json_decode($json), JSON_PRETTY_PRINT) . '</pre>'; }
— Danny Beckett
11

Ho preso il codice da 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 Il codice del compositore è buono perché si aggiorna fluentemente dalla 5.3 alla 5.4 ma codifica solo l'oggetto mentre nicejson prende le stringhe json, quindi le ho unite. Il codice può essere usato per formattare la stringa json e / o codificare oggetti, attualmente lo sto usando in un modulo 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;
}
— ulk200
fonte
Ecco come è fatto! La propria implementazione viene eseguita solo se nativo non è disponibile. Se sei sicuro che il tuo codice verrà eseguito solo in PHP 5.4 o versioni successive, puoi riposare su JSON_PRETTY_PRINT
— Heroselohim,
Questa soluzione mi dà un errore (errore di analisi: errore di sintassi, T_FUNCTION imprevisto) sulla funzione di linea ($ match)
— ARLab
— localheinz,
10

Se sei su Firefox, installa JSONovich . In realtà non è una soluzione PHP che conosco, ma fa il trucco per scopi di sviluppo / debugging.

— Jay Sidri
fonte
3
Penso che questa sia la soluzione corretta per quando si progetta un API. Offre il meglio di entrambi i mondi, un facile debug poiché puoi leggere tutto e non stai alterando il comportamento dei backend, comprese le sue prestazioni.
— Daniel,
D'accordo, è ben formattato con colori e anche pieghevole. Molto più bello di quanto si possa sperare di ottenere con un po 'di PHP
— Matthew Lock,
10

Ho usato questo:

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

Oppure usa le intestazioni php come di seguito:

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

Modo semplice per php> 5.4: come nel grafico di Facebook

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

Risultato nel browser 

{
    "a": "apple",
    "b": "banana",
    "c": "catnip"
}
— dknepa
fonte
@Madbreaks, si stampa bene nel file php, non è necessario scrivere nel file json, proprio come Facebook.
— dknepa,
6

Utilizzare <pre>in combinazione con json_encode()e l' JSON_PRETTY_PRINTopzione:

<pre>
    <?php
    echo json_encode($dataArray, JSON_PRETTY_PRINT);
    ?>
</pre>
— Andreas
fonte
6

Se hai JSON esistente ( $ugly_json)

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

Stampa a colori: soluzione minuscola

Codice:

$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];
— J Ajay
fonte
questo è stato molto utile, anche se conteneva alcuni errori. Li ho riparati e ora funziona come un incantesimo, e la funzione non è poi così grande! grazie Ajay
— Daniel,
solo per commentare le correzioni se qualcuno vuole usarlo ... aggiungi un controllo di validazione $ c> 1 nella seconda e terza condizione if, e l'ultimo eco lo avvolge in un is_array ($ s) if. quello dovrebbe coprirlo e non dovresti ricevere alcun errore di offset stringa non inizializzato.
— Daniel,
5

Puoi modificare un po 'la risposta di Kendall Hopkins nell'istruzione switch per ottenere una stampa abbastanza pulita e ben rientrata passando una stringa json nel seguente:

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;

}

Ora esegui semplicemente la funzione prettyPrint ($ your_json_string); inline nel tuo php e goditi la stampa. Se sei un minimalista e non ti piacciono le parentesi per qualche motivo, puoi sbarazzartene facilmente sostituendo il $char.="<br>";con $char="<br>";nei primi tre casi di switch su $ char. Ecco cosa ottieni per una chiamata API di google maps per la città di 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" }
— Cupcake
fonte
Grazie davvero. Una cosa che penso per aggiungere un leggero miglioramento è usare un var per: $ indent = "-----", quindi usarlo (invece di "-----" in diversi punti del codice)
— gvanto
3

Potresti farlo come sotto.

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

Sopra avrebbe prodotto un po 'come Facebook.

{
"a" : "apple",
"b" : "banana",
"c" : "catnip"
}
— Jake
fonte
Cosa succede se a_valè un array o un oggetto?
— Zach Rattner,
1
Ho risposto ad un esempio usando Json nella domanda, aggiornerò presto la mia risposta.
— Jake,
3

Custodia classica per una soluzione ricorsiva. Ecco il mio:

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\""
    }
}

Saluti

— Madbreaks
fonte
3

Questa soluzione rende JSON "davvero carino". Non esattamente quello che l'OP stava chiedendo, ma ti consente di visualizzare meglio 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);
}

}

— pgee70
fonte
2

Se lo hai usato solo $json_string = json_encode($data, JSON_PRETTY_PRINT);, otterrai nel browser qualcosa del genere (usando il link Facebook dalla domanda :)): inserisci qui la descrizione dell'immagine

ma se hai usato un'estensione Chrome come JSONView (anche senza l'opzione PHP sopra), otterrai una soluzione di debug più leggibile in cui puoi persino piegare / comprimere ogni singolo oggetto JSON facilmente in questo modo: inserisci qui la descrizione dell'immagine

— Abdelhady
fonte
1

print_r bella stampa per PHP

Esempio 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);
    }
}
— Shelly Chen
fonte
1

1 - json_encode($rows,JSON_PRETTY_PRINT);restituisce dati predefiniti con caratteri di nuova riga. Questo è utile per l'input dalla riga di comando, ma come hai scoperto non è così bello nel browser. Il browser accetterà i newline come sorgente (e quindi, visualizzare la sorgente della pagina mostrerà effettivamente il grazioso JSON), ma non sono usati per formattare l'output nei browser. I browser richiedono HTML.

2 - usa questo fith github

<?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;
    }
— SXN
fonte
0

Quanto segue è ciò che ha funzionato per me:

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

produzione:

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
)

Nota anche l'uso del tag "pre" in html.

Spero che aiuti qualcuno

— tbone
fonte
2
Questo non risponde alla domanda. Stai scaricando Vars, non stampando JSON formattato.
— Madbreaks
0

il modo migliore per formattare i dati JSON è così!

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

Sostituisci $ response con i tuoi dati che devono essere convertiti in JSON

— Resad Indipa
fonte
0

Per quelli che eseguono PHP versione 5.3 o precedente, puoi provare di seguito:

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

echo $pretty_json;
— Keith Chiah
fonte
-4

Se lavori con MVC

prova a farlo nel tuo controller

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

quindi se chiami / getLatestUsers otterrai un output piuttosto JSON;)

— webmaster
fonte
vedi il mio commento dopo l'eco in cui è piuttosto printend
— webmaster
1
MVC è un tipo di progettazione del framework, nulla a che fare con l'output di JSON.
— Maciej Paprocki
è una risposta del 2013;)
— webmaster il
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.