Wie kann ich JSON in einem Shell-Skript drucken?
Gibt es ein (Unix) Shell-Skript zum Formatieren von JSON in für Menschen lesbarer Form?
Grundsätzlich möchte ich, dass es Folgendes umwandelt:
{ "foo": "lorem", "bar": "ipsum" }
... in so etwas:
{
"foo": "lorem",
"bar": "ipsum"
}
Mit Python 2.6+ können Sie einfach Folgendes tun:
echo '{"foo": "lorem", "bar": "ipsum"}' | python -m json.tool
wenn sich der JSON in einer Datei befindet, können Sie Folgendes tun:
python -m json.tool my_json.json
wenn der JSON von einer Internetquelle wie einer API stammt, können Sie verwenden
curl http://my_url/ | python -m json.tool
In allen diesen Fällen können Sie einen Alias verwenden:
alias prettyjson='python -m json.tool'
Für noch mehr Komfort mit etwas mehr Tippen, um es vorzubereiten:
prettyjson_s() {
echo "$1" | python -m json.tool
}
prettyjson_f() {
python -m json.tool "$1"
}
prettyjson_w() {
curl "$1" | python -m json.tool
}
für alle oben genannten Fälle. Sie können dies in .bashrc eingeben und es wird jedes Mal in Shell verfügbar sein. Rufen Sie es wie prettyjson_s '{"foo": "lorem", "bar": "ipsum"}' auf.
Sie können verwenden: jq
Es ist sehr einfach zu bedienen und funktioniert super! Es kann sehr große JSON-Strukturen einschließlich Streams verarbeiten. Sie finden Ihre Tutorials hier .
Hier ist ein Beispiel:
$ jq . <<< '{ "foo": "lorem", "bar": "ipsum" }'
{
"bar": "ipsum",
"foo": "lorem"
}
Oder mit anderen Worten:
$ echo '{ "foo": "lorem", "bar": "ipsum" }' | jq .
{
"bar": "ipsum",
"foo": "lorem"
}
Ich benutze das "space" -Argument von JSON.stringify , um JSON in JavaScript zu drucken.
Beispiele:
// Indent with 4 spaces
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, 4);
// Indent with tabs
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, '\t');
Geben Sie in der Unix-Befehlszeile mit nodejs json in der Befehlszeile an:
$ node -e "console.log(JSON.stringify(JSON.parse(process.argv[1]), null, '\t'));" \
'{"foo":"lorem","bar":"ipsum"}'
Kehrt zurück:
{
"foo": "lorem",
"bar": "ipsum"
}
Geben Sie in der Unix-Befehlszeile mit Node.js einen Dateinamen an, der JSON enthält, und verwenden Sie einen Einzug aus vier Leerzeichen:
$ node -e "console.log(JSON.stringify(JSON.parse(require('fs') \
.readFileSync(process.argv[1])), null, 4));" filename.json
Mit einer Pfeife:
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));\
});\
"
Ich habe ein Tool geschrieben, das eines der besten verfügbaren "intelligenten Whitespace" -Formate hat. Es erzeugt eine lesbarere und weniger ausführliche Ausgabe als die meisten anderen Optionen hier.
So sieht "Smart Whitespace" aus:
Ich bin zwar ein bisschen voreingenommen, aber es ist ein großartiges Werkzeug zum Drucken und Bearbeiten von JSON-Daten über die Befehlszeile. Es ist sehr benutzerfreundlich und verfügt über ausführliche Befehlszeilenhilfe/Dokumentation. Es ist ein Schweizer Taschenmesser, das ich für 1001 verschiedene kleine Aufgaben benutze, die auf andere Weise überraschend ärgerlich wären.
Letzter Anwendungsfall: Chrome, Dev-Konsole, Registerkarte "Netzwerk", alle als HAR-Datei exportieren. Jetzt habe ich eine chronologisch geordnete Liste aller URL-Abrufe, die während des Ladens der Website meines Unternehmens gemacht wurden.
Hübsches Drucken ist einfach:
underscore -i data.json print
Gleiche Sache:
cat data.json | underscore print
Gleiches, expliziter:
cat data.json | underscore print --outfmt pretty
Dieses Tool ist mein aktuelles Passionsprojekt. Wenn Sie also Funktionswünsche haben, besteht eine gute Chance, dass ich sie ansprechen werde.
Ich mache normalerweise nur:
echo '{"test":1,"test2":2}' | python -mjson.tool
Und um ausgewählte Daten abzurufen (in diesem Fall den Wert "test"):
echo '{"test":1,"test2":2}' | python -c 'import sys,json;data=json.loads(sys.stdin.read()); print data["test"]'
Wenn sich die JSON-Daten in einer Datei befinden:
python -mjson.tool filename.json
Wenn Sie alles auf einmal mit curl in der Befehlszeile mit einem Authentifizierungstoken tun möchten:
curl -X GET -H "Authorization: Token wef4fwef54te4t5teerdfgghrtgdg53" http://testsite/api/ | python -mjson.tool
Dank der hilfreichen Hinweise von J. F. Sebastian, hier ein leicht verbessertes Skript, das ich mir ausgedacht habe:
#!/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 __== "__main__":
sys.exit(not main(sys.argv))
Wenn Sie npm und Node.js verwenden, können Sie npm install -g json ausführen und dann den Befehl über json weiterleiten. Führen Sie json -h aus, um alle Optionen zu erhalten. Es kann auch bestimmte Felder herausziehen und die Ausgabe mit -i einfärben.
curl -s http://search.Twitter.com/search.json?q=node.js | json
Verwenden Sie bei Perl das CPAN-Modul JSON::XS. Es installiert ein Befehlszeilenprogramm json_xs.
Bestätigen:
json_xs -t null < myfile.json
Bestätigen Sie die JSON-Datei src.json mit pretty.json:
< src.json json_xs > pretty.json
Wenn Sie json_xs nicht haben, versuchen Sie json_pp. "pp" steht für "pure Perl" - das Tool ist nur in Perl implementiert, ohne dass eine Bindung an eine externe C-Bibliothek besteht (dafür steht XS, "Extension System" von Perl).
Auf * nix funktioniert das Lesen von stdin und schreiben in stdout besser:
#!/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)
Fügen Sie dies in eine Datei ein (ich habe mein "prettyJSON" nach der Antwort von AnC benannt) in PATH und chmod +x, und Sie können loslegen.
Der JSON Ruby Gem wird mit einem Shell-Skript geliefert, um JSON zu verbessern:
Sudo gem install json
echo '{ "foo": "bar" }' | prettify_json.rb
Skript-Download: Gist.github.com/3738968
UPDATE Ich verwende jq jetzt wie in einer anderen Antwort vorgeschlagen. Es ist extrem leistungsfähig beim Filtern von JSON, aber in seiner einfachsten Form ist es auch eine großartige Möglichkeit, JSON für die Anzeige zu drucken.
jsonpp ist ein sehr hübscher JSON-Drucker.
Aus der README:
Ziemlich gedruckte Webservice-Antworten wie folgt:
curl -s -L http://<!---->t.co/tYTq5Pu | jsonppund machen Sie die Dateien auf Ihrer Festplatte schön:
jsonpp data/long_malformed.json
Wenn Sie mit Mac OS X arbeiten, können Sie brew install jsonpp. Wenn nicht, können Sie die Binärdatei einfach an eine beliebige Stelle in Ihrem $PATH kopieren.
Versuchen Sie pjson . Es hat Farben!
Installieren Sie es mit pip:
⚡ pip install pjson
Und dann den JSON-Inhalt an pjson weiterleiten.
So mach ich es:
curl yourUri | json_pp
Es verkürzt den Code und erledigt die Arbeit.
$ 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"
}
HINWEIS: Es ist nicht die - Methode, dies zu tun.
Dasselbe in Perl:
$ cat json.txt \
> | Perl -0007 -MJSON -nE'say to_json(from_json($_, {allow_nonref=>1}),
> {pretty=>1})'
{
"bar" : "ipsum",
"foo" : "lorem"
}
Hinweis 2: Wenn Sie ausführen
echo '{ "Düsseldorf": "lorem", "bar": "ipsum" }' \
| python -c'import fileinput, json;
print(json.dumps(json.loads("".join(fileinput.input())),
sort_keys=True, indent=4))'
das schön lesbare Wort wird\u00fcodiert
{
"D\u00fcsseldorf": "lorem",
"bar": "ipsum"
}
Wenn der Rest Ihrer Pipeline Unicode einwandfrei handhabt und Sie möchten, dass Ihr JSON auch benutzerfreundlich ist, einfach useensure_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)'
und du bekommst:
{
"Düsseldorf": "lorem",
"bar": "ipsum"
}
Ich benutze jshon , um genau das zu tun, was Sie beschreiben. Renn einfach:
echo $COMPACTED_JSON_TEXT | jshon
Sie können auch Argumente übergeben, um die JSON-Daten umzuwandeln.
Check out Jazor . Es ist ein einfacher, in Ruby geschriebener JSON-Parser.
gem install jazor
jazor --help
Oder mit Ruby:
echo '{ "foo": "lorem", "bar": "ipsum" }' | Ruby -r json -e 'jj JSON.parse gets'
Leiten Sie die Ausgabe einfach an jq . weiter.
Beispiel:
twurl -H ads-api.Twitter.com '.......' | jq .
JSONLint hat eine Open-Source-Implementierung auf github kann in der Befehlszeile oder in einem Projekt "node.js" verwendet werden.
npm install jsonlint -g
und dann
jsonlint -p myfile.json
oder
curl -s "http://api.Twitter.com/1/users/show/user.json" | jsonlint | less
Vanilla Bash
Ein einfaches Bash-Skript (grep/awk) für den hübschen JSON-Druck ohne Installation durch Dritte:
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}'
Beispiele:
1) Lesen Sie die Datei und drucken Sie sie in der Konsole aus
cat file.json | json_pretty.sh
2) Verwenden Sie mit Windows GIT Bash von Datei zu Datei (UTF8-basiert):
cat fileIn.json |sh.exe json_pretty.sh > fileOut.json
Pygementize
Ich kombiniere Pythons json.tool mit pygementize:
echo '{"foo": "bar"}' | python -m json.tool | pygmentize -g
Es gibt einige Alternativen zu pygementize, die in meiner Antwort aufgelistet sind.
Hier ist eine Live-Demo:
Wenn Sie mit Perl JSON :: PP von CPAN installieren, erhalten Sie den Befehl json_pp . Das Beispiel from B Bycroft stehlen erhalten Sie:
[[email protected] ~]$ echo '{"foo": "lorem", "bar": "ipsum"}' | json_pp
{
"bar" : "ipsum",
"foo" : "lorem"
}
Es ist erwähnenswert, dass json_pp mit Ubuntu 12.04 (mindestens) und Debian in /usr/bin/json_pp vorinstalliert ist.
Ich empfehle die Verwendung des Befehlszeilen-Dienstprogramms json_xs, das im Perl-Modul JSON :: XS enthalten ist. JSON :: XS ist ein Perl-Modul zum Serialisieren/Deserialisieren von JSON. Auf einem Debian- oder Ubuntu-Computer können Sie es folgendermaßen installieren:
Sudo apt-get install libjson-xs-Perl
Es ist natürlich auch auf CPAN verfügbar.
Um es zu verwenden, um JSON zu formatieren, das von einer URL abgerufen wird, können Sie curl oder wget folgendermaßen verwenden:
$ curl -s http://page.that.serves.json.com/json/ | json_xs
oder dieses:
$ wget -q -O - http://page.that.serves.json.com/json/ | json_xs
um JSON in einer Datei zu formatieren, können Sie Folgendes tun:
$ json_xs < file-full-of.json
Umformatiert als YAML , was manche Leute für menschlicher lesbar halten als JSON:
$ json_xs -t yaml < file-full-of.json
brew install jqcommand + | jq- (Beispiel:
curl localhost:5000/blocks | jq) - Genießen!
jj ist superschnell, kann ginormöse JSON-Dokumente wirtschaftlich verarbeiten, verwendet keine gültigen JSON-Nummern und ist einfach zu verwenden, z.
jj -p # for reading from STDIN
oder
jj -p -i input.json
Es ist (2018) immer noch recht neu, daher wird es möglicherweise nicht mit ungültigen JSONs wie erwartet umgehen, aber es ist einfach auf großen Plattformen zu installieren.
Installieren Sie yajl-tools mit dem folgenden Befehl:
Sudo apt-get install yajl-tools
dann,
echo '{"foo": "lorem", "bar": "ipsum"}' | json_reformat
yajl ist aus meiner Erfahrung sehr nett. Ich benutze seinen json_reformat-Befehl, um .json-Dateien in vim zu drucken, indem ich folgende Zeile in meinen .vimrc setze:
autocmd FileType json setlocal equalprg=json_reformat
Die PHP -Version, wenn Sie PHP> = 5.4 haben.
alias prettify_json=php -E '$o = json_decode($argn); print json_encode($o, JSON_PRETTY_PRINT);'
echo '{"a":1,"b":2}' | prettify_json
Verwenden Sie Ruby in einer Zeile:
echo '{"test":1,"test2":2}' | Ruby -e "require 'json'; puts JSON.pretty_generate(JSON.parse(STDIN.read))"
Und Sie können dafür einen Alias setzen:
alias to_j="Ruby -e \"require 'json';puts JSON.pretty_generate(JSON.parse(STDIN.read))\""
Dann können Sie es bequemer verwenden
echo '{"test":1,"test2":2}' | to_j
{
"test": 1,
"test2": 2
}
Und wenn Sie JSON mit Farbe anzeigen möchten, können Sie awesome_print installieren,
gem install awesome_print
dann
alias to_j="Ruby -e \"require 'json';require 'awesome_print';ap JSON.parse(STDIN.read)\""
Versuch es!
echo '{"test":1,"test2":2, "arr":["aa","bb","cc"] }' | to_j
bat ist ein cat-Klon mit Syntaxhervorhebung: https://github.com/sharkdp/bat
Beispiel:
echo '{"bignum":1e1000}' | bat -p -l json
-p wird ohne Header ausgegeben und -l wird die Sprache explizit angeben.
Es hat Farbgebung und Formatierung für Json und hat nicht die in diesem Kommentar genannten Probleme: Wie kann ich JSON in einem Shell-Skript hübsch drucken?
Ich benutze httpie
$ pip install httpie
Und du kannst es so benutzen
$ http PUT localhost:8001/api/v1/ports/my
HTTP/1.1 200 OK
Connection: keep-alive
Content-Length: 93
Content-Type: application/json
Date: Fri, 06 Mar 2015 02:46:41 GMT
Server: nginx/1.4.6 (Ubuntu)
X-Powered-By: HHVM/3.5.1
{
"data": [],
"message": "Failed to manage ports in 'my'. Request body is empty",
"success": false
}
Ich weiß, dass diese Frage ad nauseam beantwortet wurde, aber ich wollte eine Ruby-Lösung dokumentieren, die besser ist als Jsons prettify-Befehl. Der Edelstein colorful_json ist ziemlich gut.
gem install colorful_json
echo '{"foo": "lorem", "bar": "ipsum"}' | cjson
{
"foo": "lorem",
"bar": "ipsum"
}
Die Lösungen von J. F. Sebastian haben in Ubuntu 8.04 nicht funktioniert.
Hier ist eine modifizierte Perl-Version, die mit der älteren 1.X-JSON-Bibliothek funktioniert:
Perl -0007 -MJSON -ne 'print objToJson(jsonToObj($_, {allow_nonref=>1}), {pretty=>1}), "\n";'
echo "{ \"foo\": \"lorem\", \"bar\": \"ipsum\" }"|python -m json.tool
sie können diesen einfachen Befehl verwenden, um das Ergebnis zu erzielen.
$ Sudo apt-get install edit-json
$ prettify_json myfile.json
So machen Sie es mit Groovy script.
Erstellen Sie ein Groovy-Skript, sagen wir "Pretty-Print".
#!/usr/bin/env groovy
import groovy.json.JsonOutput
System.in.withReader { println JsonOutput.prettyPrint(it.readLine()) }
Skript ausführbar machen:
chmod +x pretty-print
Jetzt von der Befehlszeile aus
echo '{"foo": "lorem", "bar": "ipsum"}' | ./pretty-print
Das Tool ydump ist ein hübscher JSON-Drucker:
$ ydump my_data.json
{
"foo": "lorem",
"bar": "ipsum"
}
Oder Sie können die JSON-Pipeline eingeben:
$ echo '{"foo": "lorem", "bar": "ipsum"}' | ydump
{
"foo": "lorem",
"bar": "ipsum"
}
Dies ist wahrscheinlich die kürzeste Lösung, abgesehen von der Verwendung des Tools jq.
Dieses Werkzeug ist Teil der Bibliothek yojson für OCaml und ist hier dokumentiert.
Bei Debian und Derivaten enthält das Paket libyojson-ocaml-dev dieses Tool. Alternativ kann yojson über OPAM installiert werden.
Für Node.js können Sie auch das Modul "util" verwenden. Es verwendet Syntaxhervorhebung, intelligente Einrückung, entfernt Anführungszeichen von Schlüsseln und macht die Ausgabe einfach so hübsch, wie es nur geht.
cat file.json | node -e "process.stdin.pipe(new require('stream').Writable({write: chunk => {console.log(require('util').inspect(JSON.parse(chunk), {depth: null, colors: true}))}}))"
Ich bin der Autor von Json-Liner . Es ist ein Befehlszeilentool, um JSON in ein grep-freundliches Format umzuwandeln. Versuche es.
$ echo '{"a": 1, "b": 2}' | json-liner
/%a 1
/%b 2
$ echo '["foo", "bar", "baz"]' | json-liner
/@0 foo
/@1 bar
/@2 baz
Wenn Sie Node.js installiert haben, können Sie selbst eine mit einer Codezeile erstellen. Erstellen Sie eine Datei hübsch:
> vim hübsch
#!/usr/bin/env node
console.log(JSON.stringify(JSON.parse(process.argv[2]), null, 2));
Ausführungsberechtigung hinzufügen:
> chmod + x hübsch
> ./pretty '{"foo": "lorem", "bar": "ipsum"}'
Oder wenn sich Ihr JSON in einer Datei befindet:
#!/usr/bin/env node
console.log(JSON.stringify(require("./" + process.argv[2]), null, 2));
> ./pretty file.json
Mit JavaScript/NodeJS: Schauen Sie sich das vkBeautify.js-Plugin an, das sowohl für JSON- als auch für XML-Text hübsches Drucken ermöglicht.
Es ist in einfachem JavaScript geschrieben, weniger als 1,5 KB (minimiert) und sehr schnell.
Hier ist Groovy One-Liner:
echo '{"foo": "lorem", "bar": "ipsum"}' | groovy -e 'import groovy.json.*; println JsonOutput.prettyPrint(System.in.text)'
https://github.com/aidanmelen/json_pretty_print
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
import json
import jsonschema
def _validate(data):
schema = {"$schema": "http://json-schema.org/draft-04/schema#"}
try:
jsonschema.validate(data, schema,
format_checker=jsonschema.FormatChecker())
except jsonschema.exceptions.ValidationError as ve:
sys.stderr.write("Whoops, the data you provided does not seem to be " \
"valid JSON.\n{}".format(ve))
def pprint(data, python_obj=False, **kwargs):
_validate(data)
kwargs["indent"] = kwargs.get("indent", 4)
pretty_data = json.dumps(data, **kwargs)
if python_obj:
print(pretty_data)
else:
repls = (("u'",'"'),
("'",'"'),
("None",'null'),
("True",'true'),
("False",'false'))
print(reduce(lambda a, kv: a.replace(*kv), repls, pretty_data))
gem install jsonpretty
echo '{"foo": "lorem", "bar": "ipsum"}' | jsonpretty
Diese Methode auch "Erkennt HTTP-Antwort/Header, druckt sie unberührt und springt zu Dem Hauptteil (zur Verwendung mit` curl -i ') " .
Eine einzeilige Lösung, die nodejs verwendet, sieht folgendermaßen aus
$ node -e "console.log( JSON.stringify( JSON.parse(require('fs').readFileSync(0) ), 0, 1 ))"
für zB:
$ cat test.json | node -e "console.log( JSON.stringify( JSON.parse(require('fs').readFileSync(0) ), 0, 1 ))"
Sie können smk verwenden:
echo '{"foo": "lorem", "bar": "ipsum"}' | smk -e"JSON.stringify(JSON.parse(data), null, 4)"
In einer Zeile
echo '{"foo": "lorem", "bar": "ipsum"}' | npx smk -e"JSON.stringify(JSON.parse(data), null, 4)"
Wenn es Ihnen nichts ausmacht, ein Drittanbieter-Tool zu verwenden, können Sie sich einfach zu jsonprettyprint.org bewegen. Dies ist für den Fall, dass Sie keine Pakete auf dem Computer installieren können.
curl -XPOST https://jsonprettyprint.org/api -d '{"user" : 1}'
Überprüfen Sie auch JSONFUI: Ein JSON-Viewer für die Befehlszeile, der das Falten von
Meine JSON-Dateien wurden mit keiner dieser Methoden analysiert.
Mein Problem ähnelte diesem Beitrag Google Data Source JSON nicht gültig? .
Die Antwort auf diesen Beitrag half mir, eine Lösung zu finden. https://stackoverflow.com/a/628634/619760
Es wird als ungültiger JSON ohne die Zeichenfolgeschlüssel betrachtet.
{id:'name',label:'Name',type:'string'}
muss sein:
{"id": "name", "label": "Name", "type": "string"}
Dieser Link bietet einen umfassenden Überblick über einige der verschiedenen JSON-Parser. http://deron.meranda.us/python/comparing_json_modules/basic
Was mich zu http://deron.meranda.us/python/demjson/ führte. Ich denke, dieser Parser ist weitaus fehlertoleranter als viele andere.
Sie können Xidel verwenden.
Xidel ist ein Befehlszeilenprogramm zum Herunterladen und Extrahieren von Daten aus HTML/XML-Seiten oder JSON-APIs mit CSS, XPath 3.0, XQuery 3.0, JSONiq oder Mustervorlagen. Es können auch neue oder transformierte XML/HTML/JSON-Dokumente erstellt werden.
Xidel-Hübschdrucke standardmäßig:
$ xidel -s - -e '$json' <<< '{"foo":"lorem","bar":"ipsum"}'
{
"foo": "lorem",
"bar": "ipsum"
}
oder:
$ echo '{"foo":"lorem","bar":"ipsum"}' | xidel -s - -e .
{
"foo": "lorem",
"bar": "ipsum"
}