Ładne drukowanie JSON z PHP

587

Buduję skrypt PHP, który przekazuje dane JSON do innego skryptu. Mój skrypt buduje dane w dużej tablicy asocjacyjnej, a następnie wysyła dane za pomocą json_encode. Oto przykładowy skrypt:

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

Powyższy kod daje następujące dane wyjściowe:

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

Jest to świetne, jeśli masz niewielką ilość danych, ale wolałbym coś podobnego:

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

Czy jest sposób na zrobienie tego w PHP bez brzydkiego włamania? Wygląda na to, że ktoś na Facebooku to rozgryzł.

Zach Rattner
źródło
26
W przypadku PHP wcześniejszego niż 5.4, możesz użyć rezerwy w upgradeadephp jakoup_json_encode($data, JSON_PRETTY_PRINT);
mario
6
użycie nagłówka („Content-Type: application / json”); sprawia, że ​​przeglądarka ładnie drukuje
partho
4
Począwszy od Juy 2018, wystarczy wysłać Content-Type: application/jsonnagłówek Firefox pokaże wynik przy użyciu własnego wewnętrznego parsera JSON, a Chrome wyświetli zwykły tekst. +1 Firefox!
andreszs

Odpowiedzi:

1126

PHP 5.4 oferuje JSON_PRETTY_PRINTopcję użycia z json_encode()wywołaniem.

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

<?php
...
$json_string = json_encode($data, JSON_PRETTY_PRINT);
ekillaby
źródło
33
Dzięki, to najlepszy sposób na zrobienie tego teraz. Nie miałem php 5.4, kiedy zadałem to pytanie ...
Zach Rattner
9
5.5.3 tutaj, wydaje się, że dodaje trochę odstępów między znakami, a nie żadnego rzeczywistego wcięcia.
35
JSON nie powinien zawierać podziałów linii HTML, podczas gdy znaki nowej linii są poprawne w JSON. Jeśli chcesz wyświetlić JSON na stronie internetowej, to samodzielnie zamień ciąg znaków na znakach nowej linii lub umieść JSON w elemencie <pre> ... </pre>. Zobacz json.org, aby uzyskać informacje na temat składni.
ekillaby
13
Nie zapomnij ustawić odpowiedzi Content-Typena application/jsonjeśli chcesz przeglądarka wyświetli dość wydrukowanego JSON ładnie.
Pijusn
6
@countfloortiles to nie zadziała bezpośrednio, musisz zawrzeć wyniki w <pre>tagu typu<?php ... $json_string = json_encode($data, JSON_PRETTY_PRINT); echo "<pre>".$json_string."<pre>";
Salman Mohammad
187

Ta funkcja pobiera ciąg JSON i wcina go bardzo czytelnie. Powinien także być zbieżny,

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

Wejście

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

Wynik

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

Kod

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
źródło
84

Wielu użytkowników sugerowało skorzystanie z tej opcji

echo json_encode($results, JSON_PRETTY_PRINT);

Co jest absolutnie słuszne. Ale to nie wystarczy, przeglądarka musi zrozumieć rodzaj danych, możesz określić nagłówek tuż przed wysłaniem danych do użytkownika.

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

Spowoduje to dobrze sformatowane wyjście.

Lub, jeśli lubisz rozszerzenia, możesz użyć JSONView dla Chrome.

Wahib Zakraoui
źródło
3
Tylko ustaw nagłówek, a Firefox pokaże go idealnie przy użyciu własnego wewnętrznego parsera debugowania JSON, nie trzeba w ogóle dotykać zawartości JSON! Dziękuję Ci!!
andreszs
1
działa również w chromie. dzięki.
Don Dilanga
41

Miałem ten sam problem.

W każdym razie użyłem tutaj kodu formatującego json:

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

Działa dobrze do tego, czego potrzebowałem.

I bardziej utrzymana wersja: https://github.com/GerHobbelt/nicejson-php

Jason
źródło
Próbowałem github.com/GerHobbelt/nicejson-php i działa świetnie w PHP 5.3.
Umowa prof. Falkena została naruszona
1
Jeśli korzystasz z PHP 7.0 (i nowszych) i nadal musisz ładnie wydrukować JSON z niestandardowym wcięciem, localheinz.com/blog/2018/01/04/… powinien pomóc.
localheinz
40

Zdaję sobie sprawę, że to pytanie dotyczy sposobu zakodowania tablicy asocjacyjnej w dość sformatowanym ciągu JSON, więc nie odpowiada to bezpośrednio na pytanie, ale jeśli masz ciąg, który jest już w formacie JSON, możesz to zrobić po prostu przez dekodowanie i ponowne kodowanie (wymaga PHP> = 5.4):

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

Przykład:

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;

To daje:

{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4,
    "e": 5
}
Mikrofon
źródło
dzięki, działa tylko jeśli dodam to na górze bloku php ... nagłówek ('Content-Type: application / json');
DeyaEldeen
2
@DeyaEldeen Jeśli nie użyjesz tego nagłówka, PHP poinformuje przeglądarkę, że wysyła HTML, więc musisz zobaczyć źródło strony, aby zobaczyć sformatowany ciąg JSON. Zakładałem, że to zrozumiano, ale chyba nie. Dodałem to do mojej odpowiedzi.
Mike
I każdy, kto przegląda / przegląda plik dziennika / w powłoce unix / linux, jest to rozwiązanie tutaj! Dobry wzrok, @Mike, ułatwia czytanie!.
fusion27
@ fusion27 Nie jestem pewien, do jakich plików dziennika się odnosisz. Nigdy nie słyszałem o żadnych programach, które logowałyby cokolwiek w JSON.
Mike,
@Mike, to szybki i brudny PHP. Podkręciłem, dodając treść żądania (która jest serializowanym ciągiem JSON). Przekazałem go do mojego pliku PHP do pliku tekstowego, a następnie ogoniłem go w powłoce unix, aby móc oglądać testy POST na żywo. Używam twojej sztuczki, aby sformatować ten JSON, dzięki czemu plik tekstowy jest znacznie bardziej użyteczny.
fusion27,
24

Sklejenie kilku odpowiedzi razem odpowiada mojej potrzebie istnienia JSON:

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
źródło
3
Oto mała funkcja otoki, aby to zrobić:function json_print($json) { return '<pre>' . json_encode(json_decode($json), JSON_PRETTY_PRINT) . '</pre>'; }
Danny Beckett
11

Wziąłem kod od Composer: https://github.com/composer/composer/blob/master/src/Composer/Json/JsonFile.php i nicejson: https://github.com/GerHobbelt/nicejson-php/blob /master/nicejson.php Kod kompozytora jest dobry, ponieważ aktualizuje się płynnie z 5.3 do 5.4, ale koduje tylko obiekt, podczas gdy nicejson pobiera ciągi json, więc połączyłem je. Kod może być używany do formatowania łańcucha Json i / lub kodowania obiektów, obecnie używam go w module 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
źródło
Tak to się robi! Implementacja własna działa tylko wtedy, gdy natywna nie jest dostępna. Jeśli masz pewność, że Twój kod będzie działał tylko w PHP 5.4 lub nowszym, możesz spoczywać na JSON_PRETTY_PRINT
Heroselohim
To rozwiązanie daje mi błąd (Błąd analizy: błąd składni, nieoczekiwany T_FUNKCJA) w funkcji linii ($ dopasowanie)
ARLabs 20.01.2015
Kompozytor wziął go z daveperrett.com/articles/2008/03/11/format-json-with-php , czyli tak samo jak stackoverflow.com/a/6054389/1172545 .
localheinz
10

Jeśli korzystasz z Firefoxa, zainstaluj JSONovich . Nie do końca to rozwiązanie PHP, które znam, ale robi to sztuczkę do celów programistycznych / debugowania.

Jay Sidri
źródło
3
Myślę, że jest to właściwe rozwiązanie przy tworzeniu interfejsu API. Daje to, co najlepsze z obu światów, łatwe debugowanie, ponieważ możesz przeczytać wszystko i nie zmieniasz zachowania backendów, w tym jego wydajności.
Daniel
Uzgodniony, jest ładnie sformatowany w kolorach i również składany. O wiele ładniejszy, niż można sobie wyobrazić przy odrobinie PHP
Matthew Lock
10

Użyłem tego:

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

Lub użyj nagłówków php jak poniżej:

header('Content-type: application/json; charset=UTF-8');
echo json_encode($response, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
Bezpieczniejszy Ahmed
źródło
8

Prosty sposób na php> 5.4: jak na wykresie na Facebooku

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

Wynik w przeglądarce

{
    "a": "apple",
    "b": "banana",
    "c": "catnip"
}
dknepa
źródło
@Madbreaks, drukuje dobrze w pliku php, nie trzeba pisać w pliku json, tak jak na Facebooku.
dknepa
6

Używać <pre>w połączeniu z json_encode()oraz JSON_PRETTY_PRINTopcji:

<pre>
    <?php
    echo json_encode($dataArray, JSON_PRETTY_PRINT);
    ?>
</pre>
Andreas
źródło
6

Jeśli masz już JSON ( $ugly_json)

echo nl2br(str_replace(' ', '&nbsp;', (json_encode(json_decode($ugly_json), JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES))));
gvanto
źródło
5

Pełna kolorystyka: małe rozwiązanie

Kod:

$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
źródło
było to bardzo pomocne, chociaż zawierało kilka błędów. Naprawiłem je i teraz działa jak urok, a funkcja wcale nie jest taka duża! dzięki Ajay
Daniel
aby skomentować poprawki, jeśli ktoś chce tego użyć ... dodaj sprawdzanie poprawności $ c> 1 w drugim i trzecim warunku if, a ostatnie echo zawiń go w is_array ($ s) if. które powinno to obejmować i nie powinien pojawić się żaden błąd niezainicjowanego przesunięcia łańcucha.
Daniel
5

Możesz nieco zmodyfikować odpowiedź Kendall Hopkins w instrukcji switch, aby uzyskać ładnie wyglądający i ładnie wcięty wydruk, przekazując ciąg json w następujący sposób:

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;

}

Teraz wystarczy uruchomić funkcję prettyPrint ($ your_json_string); wstaw w swoim php i ciesz się wydrukiem. Jeśli jesteś minimalistą i z jakiegoś powodu nie lubisz nawiasów, możesz łatwo się ich pozbyć, zastępując $char.="<br>";je $char="<br>";w trzech najlepszych przypadkach przełączników na $ char. Oto, co otrzymujesz za wywołanie interfejsu API map Google dla miasta 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" }
Babeczka
źródło
To naprawdę miłe dzięki. Jedną rzeczą, którą myślę, aby dodać niewielką poprawę, jest użycie var dla: $ indent = "-----", a następnie użycie tego (zamiast „-----” w różnych miejscach kodu)
gvanto
3

Możesz to zrobić jak poniżej.

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

Powyżej wyświetliby się coś w rodzaju Facebooka.

{
"a" : "apple",
"b" : "banana",
"c" : "catnip"
}
Jake
źródło
Co jeśli a_valjest tablicą lub obiektem?
Zach Rattner
1
Odpowiedziałem na przykład, używając Jsona w pytaniu, wkrótce zaktualizuję swoją odpowiedź.
Jake
3

Klasyczna skrzynka na rozwiązanie rekurencyjne. To moje:

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

Stosowanie:

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

Twoje zdrowie

Madbreaks
źródło
3

To rozwiązanie sprawia, że ​​„naprawdę ładny” JSON. Nie do końca to, o co prosił PO, ale pozwala lepiej zwizualizować 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
źródło
2

Jeśli użyłeś tylko $json_string = json_encode($data, JSON_PRETTY_PRINT);, dostaniesz w przeglądarce coś takiego (używając linku do Facebooka z pytania :)): wprowadź opis zdjęcia tutaj

ale jeśli użyłeś chromowanego rozszerzenia, takiego jak JSONView (nawet bez powyższej opcji PHP), otrzymasz bardziej czytelne, debugowalne rozwiązanie, w którym możesz nawet złożyć / zwinąć każdy pojedynczy obiekt JSON w następujący sposób: wprowadź opis zdjęcia tutaj

AbdelHady
źródło
1

print_r ładny print dla PHP

Przykład 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
źródło
1

1 - json_encode($rows,JSON_PRETTY_PRINT); zwraca wstępnie zapisane dane ze znakami nowej linii. Jest to pomocne przy wprowadzaniu z wiersza poleceń, ale jak odkryłeś, nie wygląda tak ładnie w przeglądarce. Przeglądarka zaakceptuje nowe wiersze jako źródło (a zatem przeglądanie źródła strony rzeczywiście pokaże ładny JSON), ale nie są one używane do formatowania danych wyjściowych w przeglądarkach. Przeglądarki wymagają HTML.

2 - użyć tego fuction 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
źródło
0

Dla mnie to zadziałało:

Zawartość 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>

wynik:

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
)

Zwróć także uwagę na użycie znacznika „pre” w html.

Mam nadzieję, że komuś pomoże

tbone
źródło
2
To nie odpowiada na pytanie. Zrzucasz zmienne, a nie drukujesz sformatowanego JSON.
Madbreaks,
0

najlepszy sposób na sformatowanie danych JSON jest taki!

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

Zamień $ odpowiedz na Dane, które należy przekonwertować na JSON

Resad Indipa
źródło
0

Jeśli korzystasz z PHP w wersji 5.3 lub wcześniejszej, możesz spróbować poniżej:

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

echo $pretty_json;
Keith Chiah
źródło
-4

Jeśli pracujesz z MVC

spróbuj to zrobić w kontrolerze

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

wtedy jeśli zadzwonisz / getLatestUsers, otrzymasz niezły wynik JSON;)

webmaster
źródło
zobacz mój komentarz po echu, w którym jest dość drukowany
webmaster
1
MVC jest rodzajem projektu frameworka, nie ma nic wspólnego z tworzeniem JSON.
Maciej Paprocki
to odpowiedź od 2013 osób;)
webmaster