recorrer - JSON de impresión bonita con PHP

recorrer json php

Question

Estoy creando un script PHP que alimenta datos JSON a otro script. Mi script construye datos en una gran matriz asociativa y luego genera los datos utilizando json_encode . Aquí hay un script de ejemplo:

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

El código anterior produce el siguiente resultado:

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

Esto es genial si tiene una pequeña cantidad de datos, pero preferiría algo como este:

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

¿Hay una manera de hacer esto en PHP sin un truco feo? Parece que alguien en Facebook lo descubrió.

Answer 1

1 - json_encode($rows,JSON_PRETTY_PRINT); Devuelve datos prettificados con caracteres de nueva línea. Esto es útil para la entrada de la línea de comandos, pero como ha descubierto, no se ve tan bonito dentro del navegador. El navegador aceptará las nuevas líneas como la fuente (y, por lo tanto, ver la fuente de la página mostrará el bonito JSON), pero no se utilizan para formatear la salida en los navegadores. Los navegadores requieren HTML.

2 - utiliza este github fuction

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

Answer 2

Caso clásico para una solución recursiva. Aquí está el mío:

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

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

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

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

Uso:

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

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

Aclamaciones

Answer 3

Esta función tomará la cadena JSON y la sangrará muy legible. También debe ser convergente,

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

Entrada

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

Salida

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

Código

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

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

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

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

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

    return $result;
}

Answer 4

Esta solución hace "realmente bonito" a JSON. No es exactamente lo que el OP estaba solicitando, pero te permite visualizar mejor el 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);
}

}

Answer 5

Lo siguiente es lo que funcionó para mí:

Contenido 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>

salida:

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
)

También tenga en cuenta el uso de la etiqueta "pre" en html.

Espero que ayude a alguien

Answer 6

Manera simple para php> 5.4: como en el gráfico de Facebook

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

Resultado en el navegador

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

Answer 7

Me doy cuenta de que esta pregunta es sobre cómo codificar una matriz asociativa a una cadena JSON de formato bonito, por lo que esto no responde directamente a la pregunta, pero si tiene una cadena que ya está en formato JSON, puede hacerlo de manera bastante simple. Descodificándolo y recodificándolo (requiere PHP> = 5.4):

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

Ejemplo:

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;

Esto produce:

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

Answer 8

Muchos usuarios sugirieron que uses

echo json_encode($results, JSON_PRETTY_PRINT);

Lo cual es absolutamente correcto. Pero no es suficiente, el navegador necesita comprender el tipo de datos, puede especificar el encabezado justo antes de devolver los datos al usuario.

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

Esto dará lugar a una salida bien formateada.

O, si te gustan las extensiones, puedes usar JSONView para Chrome.

Answer 9

No tengo la reputación suficiente para responderle a Kendall Hopkins, pero encontré un error en su prettifier (también surgió de forma incómoda)

Esta línea debe ser modificada:

if( $char === ''"'' && $prev_char != ''//' ) {

a

if( $char === ''"'' && ($prev_char != ''//' && $prev_prev_char != ''//' ) {

El prettificador se rompe y produce un json no válido cuando una cadena termina con una barra invertida como la siguiente:

"kittens//"

Answer 10

PHP 5.4 ofrece la opción JSON_PRETTY_PRINT para usar con la llamada json_encode() .

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

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

Answer 11

Pegar varias respuestas se ajusta a mi necesidad de json existente:

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

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

Answer 12

Podrías hacerlo como abajo.

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

Por encima de la salida sería algo así como Facebook.

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

Answer 13

Puede modificar un poco la respuesta de Kendall Hopkins en la declaración de cambio para obtener una impresión bastante limpia y con sangría agradable pasando una cadena json a lo siguiente:

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;

}

Ahora simplemente ejecute la función prettyPrint ($ your_json_string); Inline en tu php y disfruta de la impresión. Si eres un minimalista y no te gustan los paréntesis por alguna razón, puedes deshacerte de ellos fácilmente reemplazando $char.="<br>"; con $char="<br>"; en los tres primeros casos de cambio en $ char. Esto es lo que obtiene para una llamada a la API de google maps para la ciudad 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" }

Answer 14

Si estás en JSONovich instala JSONovich . No es realmente una solución PHP que conozco, pero hace el truco para propósitos de desarrollo / depuración.

Answer 15

Si estas trabajando con MVC

intenta hacer esto en tu controlador

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

luego, si llama / getLatestUsers obtendrá una salida JSON bonita;)

Answer 16

Si solo usó $json_string = json_encode($data, JSON_PRETTY_PRINT); , obtendrás en el navegador algo como esto (usando el Facebook de la pregunta :)):

pero si JSONView una extensión de Chrome como JSONView (incluso sin la opción de PHP anterior), obtienes una solución de depuración más legible donde puedes incluso plegar / contraer cada objeto JSON con facilidad:

Answer 17

Si tienes JSON existente ( $ugly_json )

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

Answer 18

Tiene color de salida completa: Tiny Solution

Código:

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

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

Answer 19

Tomé el código de Compositor: https://github.com/composer/composer/blob/master/src/Composer/Json/JsonFile.php y nicejson: https://github.com/GerHobbelt/nicejson-php/blob/master/nicejson.php El código de https://github.com/GerHobbelt/nicejson-php/blob/master/nicejson.php Composer es bueno porque se actualiza con fluidez de 5.3 a 5.4, pero solo codifica el objeto mientras que nicejson toma cadenas json, así que las fusioné. El código se puede usar para formatear la cadena json y / o codificar objetos, actualmente lo estoy usando en un módulo Drupal.

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

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

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

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

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

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

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

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

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

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

            if ($unescapeUnicode && function_exists(''mb_convert_encoding''))
            {
                // http://.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;
}

Answer 20

Tuve el mismo problema.

De todos modos, acabo de usar el código de formato json aquí:

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

Funciona bien para lo que lo necesito.

Y una versión más mantenida: https://github.com/GerHobbelt/nicejson-php

Answer 21

Use <pre> en combinación con json_encode() y la opción JSON_PRETTY_PRINT :

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

Answer 22

print_r pretty print para PHP

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