Czy istnieje skrypt powłoki (Unix) do formatowania JSON w formie czytelnej dla człowieka?

Zasadniczo chcę, aby przekształcić następujące:

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

... w coś takiego:

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

Dzięki Python 2.6+ możesz po prostu:

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

lub, jeśli JSON znajduje się w pliku, możesz wykonać:

python -m json.tool my_json.json

jeśli JSON pochodzi ze źródła internetowego, takiego jak API, możesz użyć

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

Dla wygody we wszystkich tych przypadkach możesz utworzyć alias:

alias prettyjson='python -m json.tool'

Aby uzyskać jeszcze większą wygodę i nieco więcej pisania, aby się przygotować:

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

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

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

dla wszystkich powyższych przypadków. Możesz to włożyć .bashrci będzie ono dostępne za każdym razem w powłoce. Wywołaj to jak prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'.

Możesz użyć: jq

Jest bardzo prosty w obsłudze i działa świetnie! Obsługuje bardzo duże struktury JSON, w tym strumienie. Ich samouczki można znaleźć tutaj .

Przykłady użycia:

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

The. jest filtrem tożsamości.

Używam argumentu „spacja”, JSON.stringifyaby ładnie wydrukować JSON w JavaScript.

Przykłady:

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

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

Z wiersza polecenia systemu Unix za pomocą Node.js, określając JSON w wierszu polecenia:

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

Zwroty:

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

Z wiersza polecenia systemu Unix w Node.js, określając nazwę pliku zawierającą JSON i używając wcięcia o czterech spacjach:

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

Za pomocą rury:

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

Napisałem narzędzie, które ma jeden z najlepszych dostępnych formatów „inteligentnych białych znaków”. Daje bardziej czytelny i mniej szczegółowy wydruk niż większość innych opcji tutaj.

podkreślenie-cli

Tak wygląda „inteligentna biała spacja”:

Być może jestem nieco stronniczy, ale to niesamowite narzędzie do drukowania i manipulowania danymi JSON z wiersza poleceń. Jest bardzo przyjazny w użyciu i posiada obszerną pomoc / dokumentację z wiersza poleceń. To szwajcarski scyzoryk, którego używam do 1001 różnych małych zadań, które byłyby zaskakująco denerwujące, aby robić to w inny sposób.

Najnowszy przypadek użycia: Chrome, konsola programistów, karta Sieć, wyeksportuj wszystko jako plik HAR, „cat site.har | podkreślenie wybierz„ .url ”--outfmt tekst | grep mydomain”; teraz mam chronologicznie uporządkowaną listę wszystkich pobrań adresów URL wykonanych podczas ładowania strony mojej firmy.

Ładne drukowanie jest łatwe:

underscore -i data.json print

Ta sama rzecz:

cat data.json | underscore print

To samo, bardziej jednoznacznie:

cat data.json | underscore print --outfmt pretty

To narzędzie jest moim aktualnym projektem pasji, więc jeśli masz jakieś prośby o nowe funkcje, istnieje duża szansa, że ​​się nimi zajmę.

Zwykle po prostu robię:

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

Aby pobrać wybrane dane (w tym przypadku wartość „testową”):

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

Jeśli dane JSON znajdują się w pliku:

python -mjson.tool filename.json

Jeśli chcesz to wszystko zrobić za jednym razem, curlw wierszu polecenia za pomocą tokena uwierzytelniającego:

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

Dzięki bardzo pomocnym wskazówkom JF Sebastiana, oto nieco ulepszony skrypt, który wymyśliłem:

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

Jeśli używasz npm i Node.js, możesz to zrobić, npm install -g jsona następnie przesłać polecenie json. Zrób, json -haby uzyskać wszystkie opcje. Może także wyciągać określone pola i pokolorować wydruk -i.

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

Nie jest to zbyt proste z rodzimym sposobem za pomocą narzędzi jq .

Na przykład:

cat xxx | jq .

W Perlu użyj modułu CPAN JSON::XS. Instaluje narzędzie wiersza polecenia json_xs.

Uprawomocnić:

json_xs -t null < myfile.json

Prettify plik JSON, src.jsonaby pretty.json:

< src.json json_xs > pretty.json

Jeśli nie masz json_xs, spróbuj json_pp. „pp” dotyczy „czystego perla” - narzędzie jest implementowane tylko w Perlu, bez powiązania z zewnętrzną biblioteką C (co oznacza XS, „System rozszerzenia” Perla).

Na * nix, czytanie ze standardowego wejścia i pisanie na standardowe wyjście działa lepiej:

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

Umieść to w pliku (nazwa mojego „ładnaJSON” po odpowiedzi AnC ) w ŚCIEŻCE i chmod +xgotowe, i możesz już iść.

Rubinowy klejnot JSON jest dostarczany ze skryptem powłoki, który upiększa JSON:

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

Pobieranie skryptu: gist.github.com/3738968

AKTUALIZACJA Używam jqteraz, jak sugerowano w innej odpowiedzi. Jest niezwykle wydajny w filtrowaniu JSON, ale w najprostszym przypadku jest także świetnym sposobem na wydrukowanie JSON do oglądania.

jsonpp to bardzo ładna drukarka JSON z wiersza poleceń.

Z README:

Całkiem drukowane odpowiedzi usług internetowych, takie jak:

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

i upiększyć pliki biegające po dysku:

jsonpp data/long_malformed.json

Jeśli korzystasz z systemu Mac OS X, możesz brew install jsonpp. Jeśli nie, możesz po prostu skopiować plik binarny do dowolnego miejsca w swoim pliku $PATH.

Tak to robię:

curl yourUri | json_pp

Skraca kod i wykonuje zadanie.

prosty skrypt bash do ładnego drukowania json

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

Przykład:

cat file.json | json_pretty.sh

Spróbować pjson. Ma kolory!

Zainstaluj z pip:

⚡ pip install pjson

A następnie potokuj dowolną zawartość JSON do 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"
}

UWAGA: To nie jest sposób to zrobić.

To samo w Perlu:

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

Uwaga 2: Jeśli biegniesz

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

dobrze czytelne słowo zostanie zakodowane

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

Jeśli pozostała część Twojego potoku z wdziękiem poradzi sobie z Unicode i chcesz, aby Twój JSON był również przyjazny dla ludzi, po prostu użyj 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)'

a dostaniesz:

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

Używam jshon do robienia dokładnie tego, co opisujesz . Po prostu biegnij:

echo $COMPACTED_JSON_TEXT | jshon

Możesz także przekazać argumenty, aby przekształcić dane JSON.

Lub z Ruby:

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

Sprawdź Jazor . Jest to prosty parser JSON z linii poleceń napisany w Rubim.

gem install jazor
jazor --help

Możesz użyć tego prostego polecenia, aby osiągnąć wynik:

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

JSONLint ma implementację typu open source na GitHub, której można użyć w wierszu polecenia lub dołączyć do projektu Node.js.

npm install jsonlint -g

i wtedy

jsonlint -p myfile.json

lub

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

Po prostu potokuj wyjście do jq ..

Przykład:

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

Pigmentuj

Łączę json.tool Pythona z pygmentize:

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

Istnieje kilka alternatyw dla pygmentowania, które są wymienione w mojej odpowiedzi .

Oto demo na żywo:

W Perlu, jeśli zainstalujesz JSON :: PP z CPAN, dostaniesz polecenie json_pp . Kradnąc przykład z B Bycroft otrzymujesz:

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

Warto wspomnieć, że json_ppjest fabrycznie zainstalowany z Ubuntu 12.04 (przynajmniej) i Debianem/usr/bin/json_pp

Polecam użycie narzędzia wiersza polecenia json_xs, które jest zawarte w module perlowym JSON :: XS. JSON :: XS to moduł Perla do serializacji / deserializacji JSON, na maszynie Debian lub Ubuntu możesz go zainstalować w następujący sposób:

sudo apt-get install libjson-xs-perl

Jest oczywiście dostępny również w CPAN .

Aby użyć go do sformatowania JSON uzyskanego z adresu URL, możesz użyć curl lub wget w następujący sposób:

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

albo to:

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

i aby sformatować JSON zawarty w pliku, możesz to zrobić:

$ json_xs < file-full-of.json

Aby sformatować jako YAML , co niektórzy uważają za bardziej czytelne dla ludzi niż JSON:

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

Możesz po prostu użyć standardowych narzędzi, takich jak jq lub json_pp.

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

lub

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

będzie zarówno upiększać dane wyjściowe jak poniżej (jq nawet bardziej kolorowe):

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

Ogromną zaletą jq jest to, że może zrobić DUŻO więcej, jeśli chcesz parsować i przetwarzać json.

jj jest superszybki, potrafi ekonomicznie obsługiwać gigantyczne dokumenty JSON, nie zadziera z prawidłowymi numerami JSON i jest łatwy w użyciu, np.

jj -p # for reading from STDIN

lub

jj -p -i input.json

Jest (2018) wciąż całkiem nowy, więc może nie będzie obsługiwał nieprawidłowego JSON w oczekiwany sposób, ale łatwo go zainstalować na głównych platformach.

1. brew install jq
2. command + | jq
3. (przykład curl localhost:5000/blocks | jq:)
4. Cieszyć się!

batjest catklonem z podświetlaniem składni:

Przykład:

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

-pwyświetli bez nagłówków i -lwyraźnie określi język.

Ma kolorowanie i formatowanie dla JSON i nie ma problemów odnotowanych w tym komentarzu: Jak mogę ładnie wydrukować JSON w skrypcie powłoki?

Zainstaluj yajl-tools za pomocą poniższego polecenia:

sudo apt-get install yajl-tools

następnie,

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