Pretty-Printing JSON mit PHP

588

Ich erstelle ein PHP-Skript, das JSON-Daten einem anderen Skript zuführt. Mein Skript baut Daten in ein großes assoziatives Array ein und gibt die Daten dann mit aus json_encode. Hier ist ein Beispielskript:

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

Der obige Code liefert die folgende Ausgabe:

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

Das ist großartig, wenn Sie eine kleine Datenmenge haben, aber ich würde etwas in dieser Richtung bevorzugen:

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

Gibt es eine Möglichkeit, dies in PHP ohne einen hässlichen Hack zu tun? Es scheint, als hätte jemand bei Facebook es herausgefunden.

Zach Rattner
quelle
26
Für PHP vor 5.4 können Sie den Fallback in upgradephp alsup_json_encode($data, JSON_PRETTY_PRINT);
mario
6
Verwendung des Headers ('Content-Type: application / json'); macht Browser hübsch drucken
partho
4
Ab Juy 2018 zeigt Content-Type: application/jsonFirefox das Ergebnis nur durch Senden des Headers mit einem eigenen internen JSON-Parser an, während Chrome den Klartext anzeigt. +1 Firefox!
andreszs

Antworten:

1127

PHP 5.4 bietet die JSON_PRETTY_PRINTOption zur Verwendung mit dem json_encode()Anruf.

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

<?php
...
$json_string = json_encode($data, JSON_PRETTY_PRINT);
ekillaby
quelle
33
Danke, das ist jetzt der beste Weg. Ich hatte PHP 5.4 nicht zurück, als ich diese Frage stellte ...
Zach Rattner
9
5.5.3 hier scheint nur ein wenig Abstand zwischen den Zeichen hinzuzufügen, keine tatsächliche Einrückung.
35
JSON darf keine HTML-Zeilenumbrüche enthalten, während Zeilenumbrüche in JSON gültig sind. Wenn Sie JSON auf einer Webseite anzeigen möchten, ersetzen Sie die Zeilenumbrüche selbst durch Zeichenfolgen, oder fügen Sie den JSON in ein <pre> ... </ pre> -Element ein. Siehe json.org für die Syntaxreferenz.
Ekillaby
13
Vergessen Sie nicht, die Antwort festzulegen Content-Type, application/jsonwenn der Browser hübsch gedrucktes JSON gut anzeigen soll.
Pijusn
6
@countfloortiles es wird nicht direkt funktionieren Sie müssen Ihre Ausgabe in <pre>Tag wie<?php ... $json_string = json_encode($data, JSON_PRETTY_PRINT); echo "<pre>".$json_string."<pre>";
Salman Mohammad
187

Diese Funktion nimmt JSON-Zeichenfolgen und rückt sie gut lesbar ein. Es sollte auch konvergent sein,

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

Eingang

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

Ausgabe

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

Code

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
quelle
84

Viele Benutzer haben vorgeschlagen, dass Sie verwenden

echo json_encode($results, JSON_PRETTY_PRINT);

Welches ist absolut richtig. Es reicht jedoch nicht aus, der Browser muss den Datentyp verstehen. Sie können den Header angeben, bevor Sie die Daten an den Benutzer zurücksenden.

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

Dies führt zu einer gut formatierten Ausgabe.

Wenn Sie Erweiterungen mögen, können Sie auch JSONView für Chrome verwenden.

Wahib Zakraoui
quelle
3
Setzen Sie nur den Header und Firefox zeigt ihn perfekt mit seinem eigenen internen JSON-Debugging-Parser an, ohne den JSON-Inhalt berühren zu müssen! Vielen Dank!!
andreszs
1
funktioniert auch in Chrom. Vielen Dank.
Don Dilanga
41

Ich hatte das gleiche Problem.

Jedenfalls habe ich hier nur den JSON-Formatierungscode verwendet:

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

Funktioniert gut für das, wofür ich es brauchte.

Und eine gepflegte Version: https://github.com/GerHobbelt/nicejson-php

Jason
quelle
Ich habe github.com/GerHobbelt/nicejson-php ausprobiert und es funktioniert hervorragend in PHP 5.3.
Prof. Falken Vertrag verletzt
1
Wenn Sie mit PHP7.0 (und höher) arbeiten und JSON dennoch mit benutzerdefinierten Einrückungen drucken müssen, sollte localheinz.com/blog/2018/01/04/… hilfreich sein.
localheinz
40

Mir ist klar, dass in dieser Frage gefragt wird, wie ein assoziatives Array in eine hübsch formatierte JSON-Zeichenfolge codiert werden soll. Dies beantwortet die Frage also nicht direkt. Wenn Sie jedoch eine Zeichenfolge haben, die bereits im JSON-Format vorliegt, können Sie sie ganz einfach erstellen durch Dekodieren und Neukodieren (erfordert PHP> = 5.4):

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

Beispiel:

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;

Dies gibt aus:

{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4,
    "e": 5
}
Mike
quelle
danke, es funktioniert nur, wenn ich dies oben im PHP-Block hinzufüge ... Header ('Content-Type: application / json');
DeyaEldeen
2
@DeyaEldeen Wenn Sie diesen Header nicht verwenden, teilt PHP dem Browser mit, dass HTML gesendet wird, sodass Sie die Seitenquelle anzeigen müssen, um die formatierte JSON-Zeichenfolge anzuzeigen. Ich nahm an, dass das verstanden wurde, aber ich denke nicht. Ich habe es meiner Antwort hinzugefügt.
Mike
Und jeder, der ein Protokoll / eine Datei in der Unix / Linux-Shell verfolgt / überprüft, ist hier die Lösung! Gut aussehend, @Mike, macht es einfach zu lesen!.
Fusion27
@ fusion27 Ich bin mir nicht sicher, auf welche Protokolldateien Sie sich beziehen. Ich habe noch nie von Programmen gehört, die etwas in JSON protokollieren.
Mike
@Mike, es ist ein schnelles und schmutziges PHP, das ich erstellt habe, indem ich den Anforderungshauptteil (der eine serialisierte JSON-Zeichenfolge ist) an mein PHP in eine Textdatei gepostet habe. Anschließend habe ich ihn in der Unix-Shell gespeichert, damit ich Live-POSTs ansehen kann. Ich verwende Ihren Trick, um JSON zu formatieren und die Textdatei viel benutzerfreundlicher zu machen.
Fusion27
24

Das Zusammenkleben mehrerer Antworten passt zu meinem Bedürfnis nach vorhandenem 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
quelle
3
Hier ist eine kleine Wrapper-Funktion, um dies zu tun:function json_print($json) { return '<pre>' . json_encode(json_decode($json), JSON_PRETTY_PRINT) . '</pre>'; }
Danny Beckett
11

Ich habe den Code von Composer übernommen: https://github.com/composer/composer/blob/master/src/Composer/Json/JsonFile.php und nicejson: https://github.com/GerHobbelt/nicejson-php/blob /master/nicejson.php Composer-Code ist gut, da er fließend von 5.3 auf 5.4 aktualisiert wird, aber nur Objekte codiert, während nicejson JSON-Zeichenfolgen verwendet, sodass ich sie zusammengeführt habe. Der Code kann verwendet werden, um JSON-Zeichenfolgen zu formatieren und / oder Objekte zu codieren. Ich verwende ihn derzeit in einem Drupal-Modul.

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
quelle
So wird es gemacht! Die eigene Implementierung wird nur ausgeführt, wenn native nicht verfügbar ist. Wenn Sie sicher sind, dass Ihr Code nur in PHP 5.4 oder höher ausgeführt wird, können Sie sich auf JSON_PRETTY_PRINT
Heroselohim
Diese Lösung gibt mir Fehler (Analysefehler: Syntaxfehler, unerwartete T_FUNCTION) Online-Funktion ($ match)
ARLabs
10

Wenn Sie auf Firefox sind, installieren Sie JSONovich . Nicht wirklich eine PHP-Lösung, die ich kenne, aber sie macht den Trick für Entwicklungszwecke / Debugging.

Jay Sidri
quelle
3
Ich denke, dies ist die richtige Lösung für die Entwicklung einer API. Es bietet das Beste aus beiden Welten, einfaches Debuggen, da Sie alles lesen können und das Backend-Verhalten, einschließlich der Leistung, nicht ändern.
Daniel
Einverstanden, es ist schön mit Farben formatiert und auch zusammenklappbar. Viel schöner als man es sich mit ein bisschen PHP erhoffen könnte
Matthew Lock
10

Ich habe das benutzt:

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

Oder verwenden Sie PHP-Header wie folgt:

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

Einfacher Weg für PHP> 5.4: wie im Facebook-Diagramm

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

Ergebnis im Browser

{
    "a": "apple",
    "b": "banana",
    "c": "catnip"
}
dknepa
quelle
@ Madbreaks, es druckt gut in PHP-Datei, muss nicht in JSON-Datei schreiben, genau wie Facebook.
dknepa
6

Verwendung <pre>in Kombination mit json_encode()und der JSON_PRETTY_PRINTOption:

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

Wenn Sie bereits JSON ( $ugly_json) haben

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

Farbe voll ausgeben: Kleine Lösung

Code:

$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
quelle
Dies war sehr hilfreich, obwohl es einige Fehler enthielt. Ich habe sie repariert und jetzt funktioniert es wie ein Zauber, und die Funktion ist überhaupt nicht so groß! danke Ajay
Daniel
Nur um die Korrekturen zu kommentieren, wenn jemand dies verwenden möchte ... Fügen Sie eine Validierungsprüfung $ c> 1 in der zweiten und dritten if-Bedingung hinzu, und das letzte Echo verpackt sie in ein is_array ($ s) if. Das sollte es abdecken und Sie sollten keinen nicht initialisierten String-Offset-Fehler erhalten.
Daniel
5

Sie können die Antwort von Kendall Hopkins in der switch-Anweisung ein wenig ändern, um einen ziemlich sauber aussehenden und gut eingerückten Ausdruck zu erhalten, indem Sie eine json-Zeichenfolge wie folgt übergeben:

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;

}}

Führen Sie jetzt einfach die Funktion PrettyPrint ($ your_json_string) aus. Inline in Ihrem PHP und genießen Sie den Ausdruck. Wenn Sie eine minimalistische und nicht wie Klammern aus irgendeinem Grund sind, können Sie einfach loswerden diejenigen erhalten , indem der Austausch $char.="<br>";mit $char="<br>";in den oberen drei Schalter Fällen auf $ char. Folgendes erhalten Sie für einen Google Maps-API-Aufruf für die Stadt 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
quelle
Das ist wirklich schön, danke. Eine Sache, die ich denke, um eine leichte Verbesserung hinzuzufügen, ist die Verwendung einer Variablen für: $ indent = "-----", dann verwenden Sie diese (anstelle von "-----" an verschiedenen Stellen im Code)
gvanto
3

Sie könnten es wie unten tun.

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

Oben würde eine Art wie Facebook ausgeben.

{
"a" : "apple",
"b" : "banana",
"c" : "catnip"
}
Jake
quelle
Was ist, wenn a_vales sich um ein Array oder ein Objekt handelt?
Zach Rattner
1
Ich habe ein Beispiel mit dem Json in der Frage beantwortet. Ich werde meine Antwort bald aktualisieren.
Jake
3

Klassischer Fall für eine rekursive Lösung. Hier ist meins:

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

Verwendungszweck:

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

Prost

Madbreaks
quelle
3

Diese Lösung macht JSON wirklich hübsch. Nicht genau das, wonach das OP gefragt hat, aber Sie können den JSON besser visualisieren.

/**
 * 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
quelle
2

Wenn Sie nur verwendet haben $json_string = json_encode($data, JSON_PRETTY_PRINT);, erhalten Sie im Browser so etwas (über den Facebook-Link aus der Frage :)): Geben Sie hier die Bildbeschreibung ein

aber wenn Sie eine Chrome - Erweiterung wie verwendet JSONView (auch ohne die PHP - Option oben), dann bekommt man eine ziemlich lesbar debug Lösung , wo Sie können sogar Falten / Reduzieren jedes einzelne JSON - Objekt leicht wie folgt aus : Geben Sie hier die Bildbeschreibung ein

AbdelHady
quelle
1

print_r hübscher Druck für PHP

Beispiel 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
quelle
1

1 - json_encode($rows,JSON_PRETTY_PRINT);gibt hübsche Daten mit Zeilenumbrüchen zurück. Dies ist hilfreich für die Befehlszeileneingabe, sieht aber, wie Sie festgestellt haben, im Browser nicht so hübsch aus. Der Browser akzeptiert die Zeilenumbrüche als Quelle (und beim Anzeigen der Seitenquelle wird zwar der hübsche JSON angezeigt), sie werden jedoch nicht zum Formatieren der Ausgabe in Browsern verwendet. Browser benötigen HTML.

2 - Verwenden Sie diesen Funktionsgithub

<?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
quelle
0

Folgendes hat bei mir funktioniert:

Inhalt von 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>

Ausgabe:

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
)

Beachten Sie auch die Verwendung des Tags "pre" in HTML.

Hoffe das hilft jemandem

Knochen
quelle
2
Dies beantwortet die Frage nicht. Sie geben vars aus und drucken kein formatiertes JSON.
Madbreaks
0

Der beste Weg, um JSON-Daten zu formatieren, ist so!

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

Ersetzen Sie $ response durch Ihre Daten, die in JSON konvertiert werden müssen

Resad Indipa
quelle
0

Für diejenigen, die PHP Version 5.3 oder früher ausführen, können Sie Folgendes versuchen:

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

echo $pretty_json;
Keith Chiah
quelle
-4

Wenn Sie mit MVC arbeiten

Versuchen Sie dies in Ihrem Controller

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

Wenn Sie dann / getLatestUsers aufrufen, erhalten Sie eine hübsche JSON-Ausgabe;)

Webmaster
quelle
siehe meinen Kommentar nach dem Echo, wo es ziemlich printend ist
Webmaster
1
MVC ist eine Art Framework-Design, das nichts mit der Ausgabe von JSON zu tun hat.
Maciej Paprocki
Es ist eine Antwort von 2013 Menschen;)
Webmaster