Jolie impression JSON avec PHP

589

Je construis un script PHP qui alimente les données JSON vers un autre script. Mon script crée des données dans un grand tableau associatif, puis génère les données à l'aide json_encode. Voici un exemple de script:

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

Le code ci-dessus donne la sortie suivante:

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

C'est très bien si vous avez une petite quantité de données, mais je préférerais quelque chose dans ce sens:

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

Existe-t-il un moyen de le faire en PHP sans un hack laid? Il semble que quelqu'un sur Facebook ait compris.

Zach Rattner
la source
26
Pour PHP avant 5.4, vous pouvez utiliser le repli dans upgradephp asup_json_encode($data, JSON_PRETTY_PRINT);
mario
6
utilisation de l'en- tête ('Content-Type: application / json'); rend le navigateur joli
partho
4
À partir de Juy 2018, juste en envoyant l'en- Content-Type: application/jsontête, Firefox affichera le résultat en utilisant son propre analyseur JSON interne, tandis que Chrome affiche le texte brut. +1 Firefox!
andreszs

Réponses:

1127

PHP 5.4 offre la JSON_PRETTY_PRINTpossibilité d'utiliser avec l' json_encode()appel.

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

<?php
...
$json_string = json_encode($data, JSON_PRETTY_PRINT);
ekillaby
la source
33
Merci, c'est la meilleure façon de le faire maintenant. Je n'ai pas récupéré php 5.4 quand j'ai posé cette question ...
Zach Rattner
9
5.5.3 ici, semble simplement ajouter un peu d'espacement entre les caractères, pas de retrait réel.
35
JSON n'est pas censé contenir des sauts de ligne HTML, tandis que les caractères de nouvelle ligne sont valides dans JSON. Si vous souhaitez afficher JSON sur une page Web, effectuez vous-même un remplacement de chaîne sur les caractères de nouvelle ligne ou placez le JSON dans un élément <pre> ... </pre>. Voir json.org pour la référence de syntaxe.
ekillaby
13
Ne pas oublier de répondre ensemble Content-Typeà application/jsonsi vous voulez navigateur pour afficher JSON joli imprimé bien.
Pijusn
6
@countfloortiles cela ne fonctionnera pas directement, vous devez inclure votre sortie dans une <pre>balise comme<?php ... $json_string = json_encode($data, JSON_PRETTY_PRINT); echo "<pre>".$json_string."<pre>";
Salman Mohammad
187

Cette fonction prendra la chaîne JSON et la mettra en retrait très lisible. Il doit également être convergent,

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

Contribution

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

Production

{
    "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
la source
84

De nombreux utilisateurs ont suggéré d'utiliser

echo json_encode($results, JSON_PRETTY_PRINT);

Ce qui est tout à fait vrai. Mais cela ne suffit pas, le navigateur doit comprendre le type de données, vous pouvez spécifier l'en-tête juste avant de renvoyer les données à l'utilisateur.

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

Cela se traduira par une sortie bien formatée.

Ou, si vous aimez les extensions, vous pouvez utiliser JSONView pour Chrome.

Wahib Zakraoui
la source
3
Ne définissez que l'en-tête et Firefox le montrera parfaitement en utilisant son propre analyseur de débogage JSON interne, pas besoin de toucher du tout au contenu JSON! Je vous remercie!!
andreszs
1
fonctionne aussi en chrome. Merci.
Don Dilanga
41

J'ai eu le même problème.

Quoi qu'il en soit, je viens d'utiliser le code de formatage json ici:

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

Fonctionne bien pour ce dont j'avais besoin.

Et une version plus maintenue: https://github.com/GerHobbelt/nicejson-php

Jason
la source
J'ai essayé github.com/GerHobbelt/nicejson-php et cela fonctionne très bien en PHP 5.3.
contrat du professeur Falken a été rompu le
1
Si vous utilisez PHP7.0 (et versions ultérieures) et que vous avez encore besoin d'imprimer JSON avec une indentation personnalisée, localheinz.com/blog/2018/01/04/… devrait vous aider.
localheinz
40

Je me rends compte que cette question demande comment coder un tableau associatif en une chaîne JSON assez formatée, donc cela ne répond pas directement à la question, mais si vous avez une chaîne qui est déjà au format JSON, vous pouvez la faire assez simplement en le décodant et en le recodant (nécessite PHP> = 5.4):

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

Exemple:

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;

Cela produit:

{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4,
    "e": 5
}
Mike
la source
merci, cela ne fonctionne que si j'ajoute ceci en haut de l'en-tête du bloc php ... ('Content-Type: application / json');
DeyaEldeen
2
@DeyaEldeen Si vous n'utilisez pas cet en-tête, PHP indiquera au navigateur qu'il envoie du HTML, vous devrez donc afficher la source de la page pour voir la chaîne JSON formatée. J'ai supposé que c'était compris, mais je suppose que non. Je l'ai ajouté à ma réponse.
Mike
Et quiconque suit / examine un journal / fichier dans le shell unix / linux, c'est la solution ici! Belle recherche, @Mike, le rend facile à lire !.
fusion27
@ fusion27 Je ne sais pas vraiment à quels fichiers journaux vous faites référence. Je n'ai jamais entendu parler de programmes qui enregistrent quoi que ce soit en JSON.
Mike
@Mike, c'est un PHP rapide et sale que j'ai concocté en ajoutant le corps de la demande (qui est une chaîne JSON sérialisée) POSTÉ à mon PHP dans un fichier texte, je le copie ensuite dans le shell Unix afin de pouvoir regarder les POST en direct. J'utilise votre astuce pour formater ce JSON, ce qui rend le fichier texte beaucoup plus utilisable.
fusion27
25

Coller plusieurs réponses ensemble correspond à mon besoin de json existant:

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
la source
3
Voici une petite fonction wrapper pour ce faire:function json_print($json) { return '<pre>' . json_encode(json_decode($json), JSON_PRETTY_PRINT) . '</pre>'; }
Danny Beckett
11

J'ai pris le code de Composer: https://github.com/composer/composer/blob/master/src/Composer/Json/JsonFile.php et nicejson: https://github.com/GerHobbelt/nicejson-php/blob /master/nicejson.php Le code Composer est bon car il se met à jour couramment de 5.3 à 5.4 mais il code uniquement l'objet alors que nicejson prend des chaînes json, donc je les ai fusionnées. Le code peut être utilisé pour formater une chaîne json et / ou encoder des objets, je l'utilise actuellement dans un 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
la source
Voilà comment c'est fait! L'implémentation propre s'exécute uniquement si le natif n'est pas disponible. Si vous êtes sûr que votre code ne fonctionnera qu'en PHP 5.4 ou supérieur, vous pouvez vous reposer sur JSON_PRETTY_PRINT
Heroselohim
Cette solution me donne une erreur (erreur d'analyse: erreur de syntaxe, T_FUNCTION inattendue) sur la fonction en ligne ($ match)
ARLabs
Le compositeur l'a emprunté à daveperrett.com/articles/2008/03/11/format-json-with-php , qui est identique à stackoverflow.com/a/6054389/1172545 .
localheinz
10

Si vous êtes sur Firefox, installez JSONovich . Pas vraiment une solution PHP que je connais, mais elle fait l'affaire à des fins de développement / débogage.

Jay Sidri
la source
3
Je pense que c'est la bonne solution pour développer une API. Il offre le meilleur des deux mondes, un débogage facile car vous pouvez tout lire et vous ne modifiez pas le comportement des backends, y compris ses performances.
Daniel
D'accord, il est bien formaté avec des couleurs et pliable aussi. Beaucoup plus agréable que vous ne pourriez espérer obtenir avec un peu de PHP
Matthew Lock
10

J'ai utilisé ceci:

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

Ou utilisez les en-têtes php comme ci-dessous:

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

Un moyen simple pour php> 5.4: comme dans le graphique Facebook

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

Résultat dans le navigateur

{
    "a": "apple",
    "b": "banana",
    "c": "catnip"
}
dknepa
la source
@Madbreaks, il s'imprime bien dans le fichier php, n'a pas besoin d'écrire dans le fichier json, comme sur Facebook.
dknepa
6

Utiliser <pre>en combinaison avec json_encode()et l' JSON_PRETTY_PRINToption:

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

Si vous avez déjà JSON ( $ugly_json)

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

Avoir une sortie couleur complète: Tiny Solution

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
la source
cela a été très utile, même s'il contenait quelques erreurs. Je les ai réparés et maintenant cela fonctionne comme un charme, et la fonction n'est pas si grande du tout! merci Ajay
Daniel
juste pour commenter les correctifs si quelqu'un veut l'utiliser ... ajoutez une vérification de validation $ c> 1 dans la deuxième et la troisième condition if, et le dernier écho l'enveloppe dans un is_array ($ s) if. cela devrait le couvrir et vous ne devriez pas obtenir d'erreur de décalage de chaîne non initialisée.
Daniel
5

Vous pouvez modifier un peu la réponse de Kendall Hopkins dans l'instruction switch pour obtenir une impression assez propre et bien en retrait en passant une chaîne json dans ce qui suit:

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;

}

Il suffit maintenant d'exécuter la fonction prettyPrint ($ your_json_string); en ligne dans votre php et profitez de l'impression. Si vous êtes minimaliste et que vous n'aimez pas les supports pour une raison quelconque, vous pouvez vous en débarrasser facilement en remplaçant le $char.="<br>";par $char="<br>";dans les trois premiers commutateurs sur $ char. Voici ce que vous obtenez pour un appel API Google Maps pour la ville de Calgary

RESULTS ARE: 

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

- - - "status" : "OK" }
Cupcake
la source
C'est vraiment sympa merci. Une chose que je pense pour ajouter une légère amélioration est d'utiliser un var pour: $ indent = "-----", puis l'utiliser (au lieu de "-----" à différents endroits du code)
gvanto
3

Vous pouvez le faire comme ci-dessous.

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

Ci-dessus produirait un peu comme Facebook.

{
"a" : "apple",
"b" : "banana",
"c" : "catnip"
}
Jake
la source
Et si a_valc'est un tableau ou un objet?
Zach Rattner
1
J'ai répondu à un exemple en utilisant le Json dans la question, je mettrai à jour ma réponse bientôt.
Jake
3

Cas classique pour une solution récursive. Voici la mienne:

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

Usage:

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

À votre santé

Madbreaks
la source
3

Cette solution rend le JSON «vraiment joli». Pas exactement ce que l'OP demandait, mais cela vous permet de mieux visualiser le 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
la source
2

Si vous l'avez utilisé uniquement $json_string = json_encode($data, JSON_PRETTY_PRINT);, vous obtiendrez dans le navigateur quelque chose comme ça (en utilisant le lien Facebook de la question :)): entrez la description de l'image ici

mais si vous avez utilisé une extension chrome comme JSONView (même sans l'option PHP ci-dessus), vous obtenez une solution débogable plus lisible où vous pouvez même plier / réduire chaque objet JSON comme ceci: entrez la description de l'image ici

AbdelHady
la source
1

print_r joli print pour PHP

Exemple 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
la source
1

1 - json_encode($rows,JSON_PRETTY_PRINT);renvoie des données prettifiées avec des caractères de nouvelle ligne. Cela est utile pour la saisie en ligne de commande, mais comme vous l'avez découvert, cela ne semble pas aussi joli dans le navigateur. Le navigateur acceptera les sauts de ligne comme source (et donc, l'affichage de la page source affichera en effet le joli JSON), mais ils ne sont pas utilisés pour formater la sortie dans les navigateurs. Les navigateurs nécessitent HTML.

2 - utilisez ce 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
la source
0

Ce qui a fonctionné pour moi:

Contenu de 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>

production:

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
)

Notez également l'utilisation de la balise "pre" en html.

J'espère que cela aide quelqu'un

tbone
la source
2
Cela ne répond pas à la question. Vous videz des vars et n'imprimez pas de JSON formaté.
Madbreaks
0

la meilleure façon de formater les données JSON est comme ça!

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

Remplacez $ response par vos données qui doivent être converties en JSON

Resad Indipa
la source
0

Pour ceux qui exécutent PHP version 5.3 ou antérieure, vous pouvez essayer ci-dessous:

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

echo $pretty_json;
Keith Chiah
la source
-4

Si vous travaillez avec MVC

essayez de le faire dans votre contrôleur

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

alors si vous appelez / getLatestUsers vous obtiendrez une jolie sortie JSON;)

webmaster
la source
voir mon commentaire après l'écho où il est joli printend
webmaster
1
MVC est un type de conception de framework, rien à voir avec la sortie JSON.
Maciej Paprocki
c'est une réponse de 2013 personnes;)
webmaster