මිනිසුන්ට කියවිය හැකි ආකාරයෙන් JSON සංයුති කිරීමට (යුනික්ස්) ෂෙල් පිටපතක් තිබේද?

මූලික වශයෙන්, එය පහත සඳහන් දේ පරිවර්තනය කිරීමට මට අවශ්‍යය:

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

... මේ වගේ දෙයකට:

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

පයිතන් 2.6+ සමඟ ඔබට කළ හැක්කේ:

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

හෝ, JSON ගොනුවක තිබේ නම්, ඔබට මෙය කළ හැකිය:

python -m json.tool my_json.json

JSON API වැනි අන්තර්ජාල ප්‍රභවයකින් නම්, ඔබට භාවිතා කළ හැකිය

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"}'.

ඔයාට පාවිච්චි කරන්න පුළුවන්: jq

එය භාවිතා කිරීම ඉතා සරල වන අතර එය විශිෂ්ට ලෙස ක්‍රියා කරයි! එයට ධාරා ඇතුළු ඉතා විශාල JSON ව්‍යුහයන් හැසිරවිය හැකිය. ඔබට ඔවුන්ගේ නිබන්ධන මෙතැනින් සොයාගත හැකිය .

භාවිත උදාහරණ:

$ jq --color-output . file1.json file1.json | less -R

$ command_with_json_output | jq .

$ jq . # stdin/"interactive" mode, just enter some JSON

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

එම . අනන්‍යතා පෙරණය වේ.

මම JSON.stringifyජාවාස්ක්‍රිප්ට් හි JSON ලස්සන ලෙස මුද්‍රණය කිරීමට “අවකාශය” තර්කය භාවිතා කරමි .

උදාහරණ:

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

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

Node.js සමඟ යුනික්ස් විධාන රේඛාවෙන්, විධාන රේඛාවේ JSON සඳහන් කරන්න:

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

ප්‍රතිලාභ:

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

Node.js සමඟ යුනික්ස් විධාන රේඛාවෙන්, JSON අඩංගු ගොනු නාමයක් සඳහන් කිරීම සහ අවකාශ හතරක ඉන්ඩෙන්ට් එකක් භාවිතා කිරීම:

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

මම හොඳම "ස්මාර්ට් වයිට්ස්පේස්" ආකෘති ලබා ගත හැකි මෙවලමක් ලිවීය. මෙහි ඇති අනෙකුත් විකල්ප බොහොමයකට වඩා එය කියවිය හැකි සහ අඩු වාචික ප්‍රතිදානයක් නිපදවයි.

underscore-cli

"ස්මාර්ට් වයිට්ස්පේස්" පෙනුම මෙයයි:

මම ටිකක් පක්ෂග්‍රාහී විය හැකි නමුත් එය විධාන රේඛාවෙන් JSON දත්ත මුද්‍රණය කිරීම හා හැසිරවීම සඳහා විශිෂ්ට මෙවලමකි. එය භාවිතා කිරීමට සුපිරි හිතකාමී වන අතර පුළුල් විධාන රේඛා උදව් / ලියකියවිලි ඇත. එය ස්විට්සර්ලන්ත හමුදා පිහියක් වන අතර මම විවිධ කුඩා කාර්යයන් 1001 ක් සඳහා භාවිතා කරමි. එය වෙනත් ක්‍රමයක් කිරීමට පුදුම සහගතය.

නවතම භාවිත අවස්ථාව: ක්‍රෝම්, ඩිව් කොන්සෝලය, ජාල පටිත්ත, සියල්ල HAR ගොනුවක් ලෙස අපනයනය කරන්න, "cat site.har | අවධාරනය කරන්න '.url' --outfmt පෙළ | grep mydomain"; දැන් මගේ සමාගමේ වෙබ් අඩවිය පූරණය කිරීමේදී සාදන ලද සියලුම URL ලබාගැනීම් වල කාලානුක්‍රමිකව ඇණවුම් කළ ලැයිස්තුවක් මා සතුව ඇත.

තරමක් මුද්‍රණය කිරීම පහසුය:

underscore -i data.json print

එකම දෙය:

cat data.json | underscore print

එකම දෙය, වඩාත් පැහැදිලි:

cat data.json | underscore print --outfmt pretty

මෙම මෙවලම මගේ වර්තමාන පැෂන් ප්‍රොජෙක්ට් වේ, එබැවින් ඔබට කිසියම් විශේෂාංග ඉල්ලීමක් ඇත්නම්, මම ඒවා ආමන්ත්‍රණය කිරීමට හොඳ අවස්ථාවක් තිබේ.

මම සාමාන්‍යයෙන් කරන්නේ:

echo '{"test":1,"test2":2}' | python -mjson.tool

තෝරාගත් දත්ත ලබා ගැනීම සඳහා (මේ අවස්ථාවේ දී, "පරීක්ෂණය" හි වටිනාකම):

echo '{"test":1,"test2":2}' | python -c 'import sys,json;data=json.loads(sys.stdin.read()); print data["test"]'

JSON දත්ත ගොනුවක තිබේ නම්:

python -mjson.tool filename.json

curlසත්‍යාපන ටෝකනයක් භාවිතා කරමින් විධාන රේඛාව සමඟ එකවරම ඔබට එය කිරීමට අවශ්‍ය නම් :

curl -X GET -H "Authorization: Token wef4fwef54te4t5teerdfgghrtgdg53" http://testsite/api/ | python -mjson.tool

ජේ. එෆ්. සෙබස්තියන්ගේ ඉතා ප්‍රයෝජනවත් කරුණු වලට ස්තූතියි, මා විසින් ඉදිරිපත් කරන ලද තරමක් වැඩිදියුණු කළ පිටපතක් මෙන්න:

#!/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))

ඔබ npm හා Node.js භාවිතා කරන්නේ නම්, ඔබට කළ හැකි npm install -g jsonහරහා අණ හා පසුව නල json. කරන්න json -hසියලු විකල්ප ලබා ගැනීමට. එමඟින් විශේෂිත ක්ෂේත්‍ර ඉවත් කර ප්‍රතිදානය වර්ණ ගැන්විය හැකිය -i.

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

Jq මෙවලම් සමඟ ස්වදේශීය ආකාරයකින් එය එතරම් සරල නැත .

උදාහරණයක් වශයෙන්:

cat xxx | jq .

පර්ල් සමඟ, CPAN මොඩියුලය භාවිතා කරන්න JSON::XS. එය විධාන රේඛා මෙවලමක් ස්ථාපනය කරයි json_xs.

වලංගු කරන්න:

json_xs -t null < myfile.json

JSON ගොනුව පහතට src.jsonයොමු කරන්න pretty.json:

< src.json json_xs > pretty.json

ඔබට නොමැති නම් json_xs, උත්සාහ කරන්න json_pp. "pp" යනු "පිරිසිදු පර්ල්" සඳහා ය - මෙවලම ක්‍රියාත්මක වන්නේ බාහිර C පුස්තකාලයකට බැඳීමකින් තොරව පර්ල්හි පමණි (XS යන්නෙන් අදහස් කරන්නේ පර්ල්ගේ "ව්‍යාප්ති පද්ධතිය").

* නික්ස් හි, 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)

(මම පසුව "prettyJSON" මගේ නම් ගොනුව මෙම දාන්න ANC හි පිළිතුර) ඔබගේ PATH සහ chmod +xඑය, ඔබ යන්න ඉන්නේ හොඳ.

JSON රූබි මැණික් ෂෙල් ස්ක්‍රිප්ට් එකකින් JSON මනාව සකස් කර ඇත:

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

පිටපත් බාගත කිරීම: gist.github.com/3738968

යාවත්කාලීන කිරීම jqවෙනත් පිළිතුරක යෝජනා කර ඇති පරිදි මම දැන් භාවිතා කරමි . JSON පෙරීමෙහිදී එය අතිශයින්ම බලවත් ය, නමුත්, එහි මූලික වශයෙන්, JSON නැරඹීම සඳහා ලස්සන ලෙස මුද්‍රණය කිරීමේ විශිෂ්ට ක්‍රමයකි.

jsonpp යනු ඉතා හොඳ විධාන රේඛාවක් වන JSON ලස්සන මුද්‍රණ යන්ත්‍රයකි.

README වෙතින්:

ඒ වගේ ලස්සන මුද්‍රිත වෙබ් සේවා ප්‍රතිචාර:

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

ඔබේ තැටියේ ධාවනය වන ලිපිගොනු අලංකාර කරන්න:

jsonpp data/long_malformed.json

ඔබ මැක් ඕඑස් එක්ස් හි සිටී නම්, ඔබට හැකිය brew install jsonpp. එසේ නොවේ නම්, ඔබට ද්විමය ඔබේ කොතැනක හෝ පිටපත් කළ හැකිය $PATH.

මම එය කරන්නේ එයයි:

curl yourUri | json_pp

එය කේතය කෙටි කර කාර්යය ඉටු කරයි.

ලස්සන ජේසන් මුද්‍රණය සඳහා සරල බාෂ් පිටපතක්

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

උදාහරණයක්:

cat file.json | json_pretty.sh

උත්සාහ කරන්න pjson. එයට වර්ණ ඇත!

මෙය ස්ථාපනය කරන්න pip:

⚡ pip install pjson

ඉන්පසු ඕනෑම JSON අන්තර්ගතයක් පයිප්ප කරන්න pjson.

$ 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))'

මනාව කියවිය හැකි වචනය සංකේතවත් වේ

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

ඔබේ නල මාර්ගයේ ඉතිරි කොටස යුනිකෝඩ් හසුරුවනු ඇති අතර ඔබේ JSON ද මානව හිතකාමී වීමට කැමති නම්, සරලව භාවිතා කරන්න ensure_ascii=False

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

ඔබ විස්තර කරන දේ හරියටම කිරීමට මම jshon භාවිතා කරමි . දුවන්න:

echo $COMPACTED_JSON_TEXT | jshon

JSON දත්ත පරිවර්තනය කිරීම සඳහා ඔබට තර්ක ඉදිරිපත් කළ හැකිය.

හෝ, රූබි සමඟ:

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

ජාසෝර් බලන්න . එය රූබි භාෂාවෙන් ලියා ඇති සරල විධාන රේඛාවක් වන JSON විග්‍රහකයයි.

gem install jazor
jazor --help

ප්‍රති result ලය ලබා ගැනීම සඳහා ඔබට මෙම සරල විධානය භාවිතා කළ හැකිය:

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

JSONLint හට විධාන රේඛාවේ භාවිතා කළ හැකි හෝ Node.js ව්‍යාපෘතියකට ඇතුළත් කළ හැකි GitHub හි විවෘත මූලාශ්‍ර ක්‍රියාත්මක කිරීමක් ඇත .

npm install jsonlint -g

ඊළගට

jsonlint -p myfile.json

හෝ

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

ප්‍රතිදානය සරලව නල කරන්න jq ..

උදාහරණයක්:

twurl -H ads-api.twitter.com '.......' | jq .

පර්ල් සමඟ, ඔබ CPAN වෙතින් JSON :: PP ස්ථාපනය කළහොත් ඔබට json_pp විධානය ලැබෙනු ඇත . ඔබට ලැබෙන බී බයික්‍රොෆ්ට් වෙතින් උදාහරණය සොරකම් කිරීම :

[pdurbin@beamish ~]$ echo '{"foo": "lorem", "bar": "ipsum"}' | json_pp
{
   "bar" : "ipsum",
   "foo" : "lorem"
}

json_ppඋබුන්ටු 12.04 (අවම වශයෙන්) සහ ඩෙබියන් ඉන් සමඟ පෙර ස්ථාපනය කර ඇති බව සඳහන් කිරීම වටී/usr/bin/json_pp

Pygmentize

මම පයිතන්ගේ json.tool පිග්මන්ටයිස් සමඟ ඒකාබද්ධ කරමි:

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

මගේ පිළිතුරේ ලැයිස්තුගත කර ඇති පිග්මන්ටයිස් සඳහා විකල්ප කිහිපයක් තිබේ .

මෙන්න සජීවී නිරූපණයක්:

JSON :: XS perl මොඩියුලයට ඇතුළත් කර ඇති json_xs විධාන රේඛා උපයෝගීතාව භාවිතා කිරීමට මම නිර්දේශ කරමි. JSON :: XS යනු JSON අනුක්‍රමිකකරණය / අවලංගු කිරීම සඳහා වූ පර්ල් මොඩියුලයකි, ඩේබියන් හෝ උබුන්ටු යන්ත්‍රයක ඔබට එය මේ ආකාරයෙන් ස්ථාපනය කළ හැකිය:

sudo apt-get install libjson-xs-perl

එය පැහැදිලිවම CPAN හි ද ඇත .

URL එකකින් ලබාගත් JSON සංයුති කිරීම සඳහා එය භාවිතා කිරීම සඳහා ඔබට මේ ආකාරයට curl හෝ 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 සංයුති කිරීමට ඔබට මෙය කළ හැකිය:

$ json_xs < file-full-of.json

සමහර අය JSON ට වඩා මානුෂිකව කියවිය හැකි යැයි සලකන YAML ලෙස නැවත ආකෘතිකරණය කිරීම :

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

ඔබට සරලවම jq හෝ json_pp වැනි සම්මත මෙවලම් භාවිතා කළ හැකිය.

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

හෝ

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

දෙකම පහත දැක්වෙන ආකාරයට ප්‍රතිදානය මනාව සැකසෙනු ඇත (jq ඊටත් වඩා වර්ණවත්):

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

Jq හි ඇති විශාල වාසිය නම්, ඔබ json විග්‍රහ කර සැකසීමට කැමති නම් එයට තවත් බොහෝ දේ කළ හැකිය.

jj ඉතා වේගවත්, දැවැන්ත JSON ලේඛන ආර්ථික වශයෙන් හැසිරවිය හැකිය, වලංගු JSON අංක සමඟ පටලවා නොගනී, සහ භාවිතා කිරීමට පහසුය, උදා.

jj -p # for reading from STDIN

හෝ

jj -p -i input.json

එය (2018) තවමත් තරමක් අළුත් බැවින් සමහර විට එය ඔබ බලාපොරොත්තු වන ආකාරයට අවලංගු JSON හසුරුවන්නේ නැත, නමුත් ප්‍රධාන වේදිකාවල ස්ථාපනය කිරීම පහසුය.

1. brew install jq
2. command + | jq
3. (උදාහරණ: curl localhost:5000/blocks | jq)
4. විනෝද වන්න!

batcatසින්ටැක්ස් ඉස්මතු කරන ක්ලෝනයක්:

උදාහරණයක්:

echo '{"bignum":1e1000}' | bat -p -l json

-pශීර්ෂයන් නොමැතිව ප්‍රතිදානය -lකරනු ඇති අතර භාෂාව පැහැදිලිවම නියම කරයි.

එය JSON සඳහා වර්ණ ගැන්වීම සහ හැඩතල ගැන්වීම ඇති අතර මෙම විවරණයේ සඳහන් කර ඇති ගැටළු නොමැත : ෂෙල් ස්ක්‍රිප්ට් එකක JSON ලස්සනට මුද්‍රණය කරන්නේ කෙසේද?

පහත විධානය සමඟ yajl-tools ස්ථාපනය කරන්න:

sudo apt-get install yajl-tools

එවිට,

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