PHP के साथ सुंदर मुद्रण जेएसओएन




json pretty-print (14)

1 - json_encode($rows,JSON_PRETTY_PRINT); न्यूलाइन अक्षरों के साथ सुंदर डेटा लौटाता है। यह कमांड लाइन इनपुट के लिए सहायक है, लेकिन जैसा कि आपने पाया है ब्राउज़र के भीतर सुंदर नहीं दिखता है। ब्राउज़र न्यूलाइन को स्रोत के रूप में स्वीकार करेगा (और इस प्रकार, पृष्ठ स्रोत को देखने से वास्तव में सुंदर JSON दिखाई देगा), लेकिन इन्हें ब्राउज़र में आउटपुट प्रारूपित करने के लिए उपयोग नहीं किया जाता है। ब्राउज़र के लिए एचटीएमएल की आवश्यकता है।

2 - इस फक्शन 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;
    }

मैं एक PHP स्क्रिप्ट तैयार कर रहा हूं जो JSON डेटा को किसी अन्य स्क्रिप्ट पर फ़ीड करता है। मेरी स्क्रिप्ट डेटा को एक बड़े सहयोगी सरणी में बनाता है, और उसके बाद json_encode का उपयोग कर डेटा आउटपुट करता है। यहां एक उदाहरण स्क्रिप्ट है:

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

उपर्युक्त कोड निम्न आउटपुट उत्पन्न करता है:

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

यह बहुत अच्छा है यदि आपके पास थोड़ी सी मात्रा है, लेकिन मैं इन पंक्तियों के साथ कुछ पसंद करूंगा:

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

बिना किसी बदसूरत हैक के PHP में ऐसा करने का कोई तरीका है? ऐसा लगता है कि Facebook पर किसी ने इसे समझ लिया था।


PHP 5.4 json_encode() कॉल के साथ उपयोग के लिए JSON_PRETTY_PRINT विकल्प प्रदान करता है।

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

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

PHP के लिए सरल तरीका> 5.4: फेसबुक ग्राफ में पसंद है

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

ब्राउज़र में परिणाम

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

आप इसे नीचे की तरह कर सकते हैं।

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

ऊपर फेसबुक की तरह आउटपुट होगा।

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

एक पुनरावर्ती समाधान के लिए क्लासिक मामला। ये मेरा:

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

उपयोग:

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

चियर्स


कई उपयोगकर्ताओं ने सुझाव दिया कि आप उपयोग करते हैं

echo json_encode($results, JSON_PRETTY_PRINT);

जो बिल्कुल सही है। लेकिन यह पर्याप्त नहीं है, ब्राउज़र को डेटा के प्रकार को समझने की आवश्यकता है, आप उपयोगकर्ता को वापस डेटा को प्रतिबिंबित करने से पहले शीर्षलेख निर्दिष्ट कर सकते हैं।

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

इसके परिणामस्वरूप एक अच्छी तरह से स्वरूपित आउटपुट होगा।

या, यदि आप एक्सटेंशन पसंद करते हैं तो आप क्रोम के लिए JSONView का उपयोग कर सकते हैं।


मुझे एहसास है कि यह सवाल एक एसोसिएटिव सरणी को एक सुंदर स्वरूपित JSON स्ट्रिंग में एन्कोड करने के तरीके के बारे में पूछ रहा है, इसलिए यह सीधे प्रश्न का उत्तर नहीं देता है, लेकिन यदि आपके पास एक स्ट्रिंग है जो पहले से ही JSON प्रारूप में है, तो आप इसे बहुत सरल बना सकते हैं इसे डीकोडिंग और पुन: एन्कोडिंग करके (PHP> = 5.4 की आवश्यकता है):

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

उदाहरण:

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;

यह आउटपुट:

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

मेरी भी यही समस्या थी।

वैसे भी मैंने अभी जेसन प्रारूपण कोड का उपयोग किया है:

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

इसके लिए मुझे जो चाहिए वह अच्छी तरह से काम करता है।

और एक और बनाए रखा संस्करण: https://github.com/GerHobbelt/nicejson-php


मैंने संगीतकार से कोड लिया: https://github.com/composer/composer/blob/master/src/Composer/Json/JsonFile.php और nicejson: https://github.com/GerHobbelt/nicejson-php/blob/master/nicejson.php संगीतकार कोड अच्छा है क्योंकि यह 5.3 से 5.4 तक स्पष्ट रूप से अपडेट होता है लेकिन यह केवल ऑब्जेक्ट को एन्कोड करता है जबकि गुडजसन जेसन स्ट्रिंग लेता है, इसलिए मैंने उन्हें विलय कर दिया। कोड का उपयोग जेसन स्ट्रिंग और / या एन्कोड ऑब्जेक्ट को प्रारूपित करने के लिए किया जा सकता है, मैं वर्तमान में इसे ड्रूपल मॉड्यूल में उपयोग कर रहा हूं।

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

यदि आप एमवीसी के साथ काम कर रहे हैं

इसे अपने नियंत्रक में करने का प्रयास करें

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

तो अगर आप कॉल / getLatestUsers को कॉल करते हैं तो आपको एक सुंदर JSON आउटपुट मिलेगा;)


यदि आपके पास मौजूदा JSON ( $ugly_json ) है

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

यदि आपने केवल $json_string = json_encode($data, JSON_PRETTY_PRINT); , आप इस तरह ब्राउज़र में कुछ प्राप्त करेंगे (प्रश्न से Facebook का उपयोग कर :)):

लेकिन यदि आपने JSONView (यहां तक ​​कि PHP विकल्प के बिना भी) क्रोम एक्सटेंशन का उपयोग किया है, तो आपको एक और अधिक पठनीय डिबगबल समाधान मिलता है जहां आप आसानी से इस तरह के प्रत्येक JSON ऑब्जेक्ट को फोल्ड / संकुचित भी कर सकते हैं:


रंग पूर्ण आउटपुट है: छोटे समाधान

कोड:

$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];

JSON_PRETTY_PRINT json_encode() और JSON_PRETTY_PRINT विकल्प के साथ संयोजन में <pre> उपयोग करें:

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




pretty-print