json - मैं शैल स्क्रिप्ट में जेएसओएन को सुंदर-प्रिंट कैसे कर सकता हूं?




unix command-line format pretty-print (25)

या, रूबी के साथ:

echo '{ "foo": "lorem", "bar": "ipsum" }' | ruby -r json -e 'jj JSON.parse gets'

क्या मानव-पठनीय रूप में जेएसओएन प्रारूपित करने के लिए एक (यूनिक्स) खोल स्क्रिप्ट है?

असल में, मैं इसे निम्नलिखित में बदलना चाहता हूं:

{ "foo": "lorem", "bar": "ipsum" }

... इस तरह कुछ में:

{
    "foo": "lorem",
    "bar": "ipsum"
}

यह jq टूल्स के साथ देशी तरीके से बहुत आसान नहीं है।

उदाहरण के लिए:

cat xxx | jq .

अद्यतन मैं अब jq का उपयोग कर रहा हूं जैसा कि किसी अन्य उत्तर में सुझाया गया है। JSON फ़िल्टर करने में यह बेहद शक्तिशाली है, लेकिन, इसके सबसे बुनियादी पर, देखने के लिए JSON को प्रिंट करने का एक शानदार तरीका भी है।

jsonpp एक बहुत अच्छी कमांड लाइन JSON सुंदर प्रिंटर है।

रीडमे से:

इस तरह के बहुत प्रिंट वेब सेवा प्रतिक्रियाएं:

curl -s -L http://<!---->t.co/tYTq5Pu | jsonpp

और अपनी डिस्क पर चल रही फ़ाइलों को सुंदर बनाएं:

jsonpp data/long_malformed.json

यदि आप मैक ओएस एक्स पर हैं, तो आप brew install jsonpp कर सकते हैं। यदि नहीं, तो आप बाइनरी को अपने $PATH में कहीं भी कॉपी कर सकते हैं।


मैंने एक उपकरण लिखा है जिसमें सबसे अच्छा "स्मार्ट व्हाइटस्पेस" प्रारूपक उपलब्ध है। यह यहां के अधिकांश विकल्पों की तुलना में अधिक पठनीय और कम वर्बोज़ आउटपुट उत्पन्न करता है।

underscore-cli

यह "स्मार्ट व्हाइटस्पेस" जैसा दिखता है:

मैं थोड़ी पक्षपातपूर्ण हो सकता हूं, लेकिन यह कमांड लाइन से जेएसओएन डेटा को छपाई और छेड़छाड़ करने के लिए एक शानदार उपकरण है। यह उपयोग करने के लिए अति-अनुकूल है और इसमें व्यापक कमांड लाइन सहायता / दस्तावेज़ीकरण है। यह एक स्विस सेना चाकू है जिसका उपयोग मैं 1001 विभिन्न छोटे कार्यों के लिए करता हूं जो किसी भी अन्य तरीके से आश्चर्यजनक रूप से परेशान होंगे।

नवीनतम उपयोग-मामला: क्रोम, देव कंसोल, नेटवर्क टैब, सभी को एचएआर फ़ाइल के रूप में निर्यात करें, "cat site.har | underscore select '.url' --outfmt text | grep mydomain"; अब मेरी कंपनी की साइट के लोड होने के दौरान किए गए सभी यूआरएल लाने की क्रोनोलॉजिकल ऑर्डर की गई सूची है।

सुंदर प्रिंटिंग आसान है:

underscore -i data.json print

वही चीज:

cat data.json | underscore print

वही बात, अधिक स्पष्ट:

cat data.json | underscore print --outfmt pretty

यह टूल मेरा वर्तमान जुनून प्रोजेक्ट है, इसलिए यदि आपके पास कोई फीचर अनुरोध है, तो मुझे एक अच्छा मौका मिलेगा कि मैं उन्हें संबोधित करूंगा।


जेएफ सेबेस्टियन के बहुत उपयोगी पॉइंटर्स के लिए धन्यवाद, यहां एक छोटी सी लिपि गई स्क्रिप्ट है जिसके साथ मैं आया हूं:

#!/usr/bin/python

"""
Convert JSON data to human-readable form.

Usage:
  prettyJSON.py inputFile [outputFile]
"""

import sys
import simplejson as json


def main(args):
    try:
        if args[1] == '-':
            inputFile = sys.stdin
        else:
            inputFile = open(args[1])
        input = json.load(inputFile)
        inputFile.close()
    except IndexError:
        usage()
        return False
    if len(args) < 3:
        print json.dumps(input, sort_keys = False, indent = 4)
    else:
        outputFile = open(args[2], "w")
        json.dump(input, outputFile, sort_keys = False, indent = 4)
        outputFile.close()
    return True


def usage():
    print __doc__


if __name__ == "__main__":
    sys.exit(not main(sys.argv))

* निक्स पर, stdin से पढ़ने और stdout लिखने के लिए बेहतर काम करता है:

#!/usr/bin/env python
"""
Convert JSON data to human-readable form.

(Reads from stdin and writes to stdout)
"""

import sys
try:
    import simplejson as json
except:
    import json

print json.dumps(json.loads(sys.stdin.read()), indent=4)
sys.exit(0)

इसे एक फ़ाइल में रखें (मैंने AnC के जवाब के बाद मेरा "सुंदरजसन" नाम दिया है) अपने पैथ और chmod +x , और आप जाने के लिए अच्छे हैं।


$ echo '{ "foo": "lorem", "bar": "ipsum" }' \
> | python -c'import fileinput, json;
> print(json.dumps(json.loads("".join(fileinput.input())),
>                  sort_keys=True, indent=4))'
{
    "bar": "ipsum",
    "foo": "lorem"
}

नोट: यह करने का तरीका नहीं है।

पर्ल में वही:

$ cat json.txt \
> | perl -0007 -MJSON -nE'say to_json(from_json($_, {allow_nonref=>1}), 
>                                     {pretty=>1})'
{
   "bar" : "ipsum",
   "foo" : "lorem"
}

नोट 2: यदि आप भागते हैं

echo '{ "Düsseldorf": "lorem", "bar": "ipsum" }' \
| python -c'import fileinput, json;
print(json.dumps(json.loads("".join(fileinput.input())),
                 sort_keys=True, indent=4))'

अच्छी तरह से पठनीय शब्द \ u एन्कोडेड हो जाता है

{
    "D\u00fcsseldorf": "lorem", 
    "bar": "ipsum"
}

यदि आपकी पाइपलाइन का शेष ensure_ascii=False यूनिकोड को संभाल लेगा और आप चाहते हैं कि आपका JSON मानव-अनुकूल भी हो, तो बस ensure_ascii=False use

echo '{ "Düsseldorf": "lorem", "bar": "ipsum" }' \
| python -c'import fileinput, json;
print json.dumps(json.loads("".join(fileinput.input())),
                 sort_keys=True, indent=4, ensure_ascii=False)'

और आप पाएंगे:

{
    "Düsseldorf": "lorem", 
    "bar": "ipsum"
}

  1. brew install jq
  2. command + | jq
  3. (उदाहरण: curl localhost:5000/blocks | jq )
  4. का आनंद लें!


PHP संस्करण, यदि आपके पास PHP> = 5.4 है।

alias prettify_json=php -E '$o = json_decode($argn); print json_encode($o, JSON_PRETTY_PRINT);'
echo '{"a":1,"b":2}' | prettify_json

मैं json_xs कमांड लाइन उपयोगिता का उपयोग करने की अनुशंसा करता हूं जो JSON :: XS perl मॉड्यूल में शामिल है। JSON :: XS एक डेबियन या उबंटू मशीन पर जेएसओएन को क्रमबद्ध / deserializing के लिए एक पर्ल मॉड्यूल है, आप इसे इस तरह स्थापित कर सकते हैं:

sudo apt-get install libjson-xs-perl

यह स्पष्ट रूप से CPAN पर भी उपलब्ध है।

किसी URL से प्राप्त JSON को प्रारूपित करने के लिए इसका उपयोग करने के लिए आप इस तरह कर्ल या wget का उपयोग कर सकते हैं:

$ curl -s http://page.that.serves.json.com/json/ | json_xs

या यह:

$ wget -q -O - http://page.that.serves.json.com/json/ | json_xs

और फ़ाइल में निहित जेएसओएन प्रारूपित करने के लिए आप यह कर सकते हैं:

$ json_xs < file-full-of.json

YAML रूप में सुधार करने के लिए, जो कुछ लोग जेएसओएन की तुलना में अधिक मानवीय-पठनीय मानते हैं:

$ json_xs -t yaml < file-full-of.json

मैं जो भी वर्णन कर रहा jshon उसे ठीक करने के लिए मैं jshon का उपयोग करता jshon । बस दौडो:

echo $COMPACTED_JSON_TEXT | jshon

आप JSON डेटा को बदलने के लिए तर्क भी पास कर सकते हैं।


Pygmentize

मैं पायथन के साथ पाइथन की json.tool गठबंधन:

echo '{"foo": "bar"}' | python -m json.tool | pygmentize -g

Pygmentize के कुछ विकल्प हैं जो मेरे इस जवाब में सूचीबद्ध हैं।

यहां एक लाइव डेमो है:


पायथन 2.6+ के साथ आप बस कर सकते हैं:

echo '{"foo": "lorem", "bar": "ipsum"}' | python -m json.tool

या, यदि JSON एक फ़ाइल में है, तो आप कर सकते हैं:

python -m json.tool my_json.json

यदि JSON किसी एपीआई जैसे इंटरनेट स्रोत से है, तो आप इसका उपयोग कर सकते हैं

curl http://my_url/ | python -m json.tool

इन सभी मामलों में सुविधा के लिए आप उपनाम बना सकते हैं:

alias prettyjson='python -m json.tool'

इसे तैयार करने के लिए थोड़ा और टाइपिंग के साथ और भी सुविधा के लिए:

prettyjson_s() {
    echo "$1" | python -m json.tool
}

prettyjson_f() {
    python -m json.tool "$1"
}

prettyjson_w() {
    curl "$1" | python -m json.tool
}

उपरोक्त सभी मामलों के लिए। आप इसे .bashrc में डाल सकते हैं और यह हर बार खोल में उपलब्ध होगा। इसे prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'


पर्ल के साथ, यदि आप सीपीएएन से JSON::PP स्थापित करते हैं तो आपको json_pp कमांड मिल जाएगा। बी बाईक्रॉफ्ट से example चोरी करना आपको मिलता है:

[[email protected] ~]$ echo '{"foo": "lorem", "bar": "ipsum"}' | json_pp
{
   "bar" : "ipsum",
   "foo" : "lorem"
}

यह उल्लेखनीय है कि json_pp उबंटू 12.04 (कम से कम) और डेबियन /usr/bin/json_pp साथ पूर्व-स्थापित /usr/bin/json_pp


पर्ल के साथ, सीपीएएन मॉड्यूल JSON::XS उपयोग करें। यह एक कमांड लाइन उपकरण json_xs स्थापित करता है।

मान्य करें:

json_xs -t null < myfile.json

JSON फ़ाइल src.json को pretty.json को pretty.json :

< src.json json_xs > pretty.json

यदि आपके पास json_xs नहीं है, तो json_xs json_pp । "पीपी" "शुद्ध पर्ल" के लिए है - उपकरण को केवल बाह्य पब्लिक लाइब्रेरी (जो एक्सएस का खड़ा है, पर्ल की "एक्सटेंशन सिस्टम") के बाध्यकारी के बिना पर्ल में लागू किया जाता है।


JSONLint पास JSONLint पर ओपन-सोर्स कार्यान्वयन कमांड लाइन पर इस्तेमाल किया जा सकता है या node.js प्रोजेक्ट में शामिल किया जा सकता है।

npm install jsonlint -g

और फिर

jsonlint -p myfile.json

या

curl -s "http://api.twitter.com/1/users/show/user.json" | jsonlint | less

वेनिला बैश

तीसरे पक्ष के इंस्टॉल के बिना, सुंदर जेएसओएन प्रिंटिंग के लिए एक सरल बैश स्क्रिप्ट ( grep / awk ):

json_pretty.sh

#/bin/bash

grep -Eo '"[^"]*" *(: *([0-9]*|"[^"]*")[^{}\["]*|,)?|[^"\]\[\}\{]*|\{|\},?|\[|\],?|[0-9 ]*,?' | awk '{if ($0 ~ /^[}\]]/ ) offset-=4; printf "%*c%s\n", offset, " ", $0; if ($0 ~ /^[{\[]/) offset+=4}'

उदाहरण:

1) कंसोल में फ़ाइल और सुंदर प्रिंट पढ़ें

cat file.json | json_pretty.sh

2) विंडो से फ़ाइल (यूटीएफ 8 आधारित) से विंडोज जीआईटी बैश के साथ प्रयोग करें:

cat fileIn.json |sh.exe json_pretty.sh > fileOut.json

इस तरह मैं यह करता हूं:

gem install jazor
jazor --help

यह कोड को छोटा करता है और काम पूरा करता है।


यदि आप npm और node.js का उपयोग करते हैं, तो आप npm install -g json कर सकते हैं और फिर npm install -g json माध्यम से कमांड पाइप कर सकते हैं। सभी विकल्पों को पाने के लिए json -h करें। यह विशिष्ट फ़ील्ड भी खींच सकता है और आउटपुट को -i साथ रंगीन कर सकता है।

curl -s http://search.twitter.com/search.json?q=node.js | json

jj सुपर-फास्ट है, आर्थिक रूप से विशाल JSON दस्तावेजों को संभाल सकता है, वैध JSON संख्याओं के साथ गड़बड़ नहीं करता है, और उपयोग करना आसान है, उदाहरण के लिए

jj -p # for reading from STDIN

या

jj -p -i input.json

यह अभी भी काफी नया है (2018) तो शायद यह आपके द्वारा अपेक्षित तरीके से अमान्य JSON को संभाल नहीं पाएगा, लेकिन प्रमुख प्लेटफ़ॉर्म पर इंस्टॉल करना आसान है।


मैं JSON.stringify के "स्पेस" तर्क का JSON.stringify जावास्क्रिप्ट में सुंदर प्रिंट JSON करने के लिए करता JSON.stringify

उदाहरण:

// Indent with 4 spaces
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, 4);

// Indent with tabs
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, '\t');

यूनिक्स कमांड लाइन से नोडजेस के साथ, कमांड लाइन पर जेसन निर्दिष्ट करना:

$ node -e "console.log(JSON.stringify(JSON.parse(process.argv[1]), null, '\t'));" \
  '{"foo":"lorem","bar":"ipsum"}'

यह दिखाता है:

{
    "foo": "lorem",
    "bar": "ipsum"
}

यूनिक्स कमांड लाइन से नोड.जेएस के साथ, जेएसओएन युक्त फ़ाइल नाम निर्दिष्ट करना और चार रिक्त स्थानों का इंडेंट का उपयोग करना:

$ node -e "console.log(JSON.stringify(JSON.parse(require('fs') \
      .readFileSync(process.argv[1])), null, 4));"  filename.json

एक पाइप का उपयोग करना:

echo '{"foo": "lorem", "bar": "ipsum"}' | node -e \
"\
 s=process.openStdin();\
 d=[];\
 s.on('data',function(c){\
   d.push(c);\
 });\
 s.on('end',function(){\
   console.log(JSON.stringify(JSON.parse(d.join('')),null,2));\
 });\
"

JSON रूबी जेम JSON को प्रसन्न करने के लिए एक शेल स्क्रिप्ट के साथ बंडल किया गया है:

sudo gem install json
echo '{ "foo": "bar" }' | prettify_json.rb

स्क्रिप्ट डाउनलोड: gist.github.com/3738968


आप इसका उपयोग कर सकते हैं: jq

इसका उपयोग करना बहुत आसान है और यह बहुत अच्छा काम करता है! यह धाराओं सहित बहुत बड़ी JSON संरचनाओं को संभाल सकता है। आप here उनके ट्यूटोरियल पा सकते हैं।

यहाँ एक उदाहरण है:

$ jq . <<< '{ "foo": "lorem", "bar": "ipsum" }'
{
  "bar": "ipsum",
  "foo": "lorem"
}

या दूसरे शब्दों में:

$ echo '{ "foo": "lorem", "bar": "ipsum" }' | jq .
{
  "bar": "ipsum",
  "foo": "lorem"
}

नीचे दिए गए आदेश के साथ yajl-tools इंस्टॉल करें:

sudo apt-get install yajl-tools

फिर,

echo '{"foo": "lorem", "bar": "ipsum"}' | json_reformat


ढूंढें और xargs आपके दोस्त हैं। Grep के अलावा फ़ाइल सूची को फ़िल्टर करने के लिए उनका उपयोग करें - बहिष्कृत करें

कुछ ऐसा करने की कोशिश करो

find . -not -name '*.png' -o -type f -print | xargs grep -icl "foo="






json unix command-line format pretty-print