Jak mohu JSON v tiskovém prostředí Shell vytisknout?
Existuje (Unix) Shell skript pro formátování JSONu v lidské čitelné formě?
V podstatě chci, aby změnila následující:
{ "foo": "lorem", "bar": "ipsum" }
... do něčeho takového:
{
"foo": "lorem",
"bar": "ipsum"
}
S Pythonem 2.6+ si můžete udělat:
echo '{"foo": "lorem", "bar": "ipsum"}' | python -m json.tool
nebo pokud je soubor JSON v souboru, můžete:
python -m json.tool my_json.json
pokud je JSON z internetového zdroje, jako je API, můžete použít
curl http://my_url/ | python -m json.tool
Pro zjednodušení ve všech těchto případech můžete vytvořit alias:
alias prettyjson='python -m json.tool'
Pro ještě větší pohodlí s trochou více psaní, aby bylo vše připraveno:
prettyjson_s() {
echo "$1" | python -m json.tool
}
prettyjson_f() {
python -m json.tool "$1"
}
prettyjson_w() {
curl "$1" | python -m json.tool
}
pro všechny výše uvedené případy. Můžete to dát do .bashrc a bude k dispozici pokaždé v Shell. Vyvolejte to jako prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'.
Můžete použít: jq
Je to velmi jednoduché použití a funguje to skvěle! Dokáže zpracovat velmi velké struktury JSON, včetně toků. Můžete najít Jejich tutoriály zde .
Zde je příklad:
$ jq . <<< '{ "foo": "lorem", "bar": "ipsum" }'
{
"bar": "ipsum",
"foo": "lorem"
}
Nebo jinými slovy:
$ echo '{ "foo": "lorem", "bar": "ipsum" }' | jq .
{
"bar": "ipsum",
"foo": "lorem"
}
Používám argument "space" z JSON.stringify pro hezký tisk JSON v JavaScriptu.
Příklady:
// Indent with 4 spaces
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, 4);
// Indent with tabs
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, '\t');
Z příkazového řádku Unixu s nodejs zadáním příkazu json na příkazovém řádku:
$ node -e "console.log(JSON.stringify(JSON.parse(process.argv[1]), null, '\t'));" \
'{"foo":"lorem","bar":"ipsum"}'
Vrací:
{
"foo": "lorem",
"bar": "ipsum"
}
Z příkazového řádku Unixu s Node.js určením názvu souboru, který obsahuje JSON, a pomocí odsazení čtyř mezer:
$ node -e "console.log(JSON.stringify(JSON.parse(require('fs') \
.readFileSync(process.argv[1])), null, 4));" filename.json
Použití potrubí:
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));\
});\
"
Napsal jsem nástroj, který má k dispozici jeden z nejlepších formátů "inteligentních mezer". To produkuje čitelnější a méně verbose výstup než většina ostatních možností zde.
Takto vypadá "inteligentní prázdné místo":
Možná jsem trochu zaujatý, ale je to úžasný nástroj pro tisk a manipulaci s daty JSON z příkazového řádku. Je to super-přátelský k použití a má rozsáhlou nápovědu/dokumentaci příkazového řádku. Je to švýcarský armádní nůž, který používám pro 1001 různých drobných úkolů, což by bylo překvapivě nepříjemné dělat jinak.
Poslední případ použití: Chrome, Dev konzole, záložka Síť, export všech jako HAR soubor, "cat site.har | underscore vyberte" .url "--outfmt text | grep mydomain"; nyní mám chronologicky uspořádaný seznam všech načtených adres URL během načítání stránek mé společnosti.
Pěkný tisk je snadný:
underscore -i data.json print
Stejná věc:
cat data.json | underscore print
Stejná věc, jasnější:
cat data.json | underscore print --outfmt pretty
Tento nástroj je můj současný projekt vášeň, takže pokud máte nějaké požadavky na funkce, je tu velká šance, že se jim budu věnovat.
Obvykle to jen dělám:
echo '{"test":1,"test2":2}' | python -mjson.tool
A načíst vybraná data (v tomto případě hodnota "test"):
echo '{"test":1,"test2":2}' | python -c 'import sys,json;data=json.loads(sys.stdin.read()); print data["test"]'
Pokud jsou data JSON v souboru:
python -mjson.tool filename.json
Chcete-li to provést najednou, zadejte příkaz curl na příkazovém řádku pomocí ověřovacího tokenu:
curl -X GET -H "Authorization: Token wef4fwef54te4t5teerdfgghrtgdg53" http://testsite/api/ | python -mjson.tool
Díky velmi užitečným ukazatelům J.F. Sebastiana, zde je mírně vylepšený skript, se kterým jsem přišel:
#!/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))
Použijete-li npm a Node.js, můžete provést npm install -g json a pak příkaz přes json. Do json -h získat všechny možnosti. To může také vytáhnout konkrétní pole a zbarvení výstupu s -i.
curl -s http://search.Twitter.com/search.json?q=node.js | json
Pomocí Perlu použijte modul CPAN JSON::XS. Nainstaluje nástroj příkazového řádku json_xs.
Ověřit:
json_xs -t null < myfile.json
Přednastavení souboru JSON src.json do pretty.json:
< src.json json_xs > pretty.json
Pokud nemáte json_xs, zkuste json_pp. "pp" je pro "čistý Perl" - nástroj je implementován pouze v Perlu, bez vazby na externí knihovnu C (což je to, co znamená XS, Perlův "Extension System").
Na * nix, čtení ze stdin a zápis na stdout funguje lépe:
#!/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)
Dej to do souboru (pojmenoval jsem svou "prettyJSON" po odpověď AnC ') ve vašem PATH a chmod +x a je dobré jít.
JSON Ruby Gem je dodáván s skriptem Shell, aby předstihl JSON:
Sudo gem install json
echo '{ "foo": "bar" }' | prettify_json.rb
Stahování skriptů: Gist.github.com/3738968
UPDATE Používám jq nyní, jak bylo navrženo v jiné odpovědi. Je extrémně výkonný při filtrování JSON, ale na jeho nejzákladnější, také úžasný způsob, jak docela tisk JSON pro prohlížení.
jsonpp je velmi pěkný příkazový řádek JSON hezká tiskárna.
Z README:
Odezvy webových služeb, jako je například:
curl -s -L http://<!---->t.co/tYTq5Pu | jsonppa zpříjemnit soubory na vašem disku:
jsonpp data/long_malformed.json
Pokud jste v systému Mac OS X, můžete brew install jsonpp. Pokud ne, můžete jednoduše zkopírovat binární soubor někam do $PATH.
Zkuste pjson . Má barvy!
Nainstalujte ji pomocí pip:
⚡ pip install pjson
A pak zaveďte obsah JSON do pjson.
Tak to dělám:
curl yourUri | json_pp
Zkracuje kód a provede úlohu.
Používám jshon k tomu, co přesně popisujete. Prostě běž:
echo $COMPACTED_JSON_TEXT | jshon
Můžete také předat argumenty pro transformaci dat JSON.
Podívejte se na Jazor . Je to jednoduchý příkazový řádek JSON parser napsaný v Ruby.
gem install jazor
jazor --help
Nebo s Ruby:
echo '{ "foo": "lorem", "bar": "ipsum" }' | Ruby -r json -e 'jj JSON.parse gets'
Jednoduše připojte výstup na jq ..
Příklad:
twurl -H ads-api.Twitter.com '.......' | jq .
JSONLint má implementaci open-source na github lze použít na příkazovém řádku nebo zahrnout do projektu node.js.
npm install jsonlint -g
a pak
jsonlint -p myfile.json
nebo
curl -s "http://api.Twitter.com/1/users/show/user.json" | jsonlint | less
Vanilková Bash
Jednoduchý skript Bash (grep/awk) pro hezký tisk JSON bez instalace třetí stranou:
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}'
Příklady:
1) Přečtěte si soubor a hezky tiskněte v konzole
cat file.json | json_pretty.sh
2) Použití s okny GIT Bash ze souboru do souboru (na bázi UTF8):
cat fileIn.json |sh.exe json_pretty.sh > fileOut.json
Pokud instalujete JSON :: PP z CPAN, dostanete Perl, kde získáte příkaz json_pp . Krást příklad z B Bycroft dostanete:
[[email protected] ~]$ echo '{"foo": "lorem", "bar": "ipsum"}' | json_pp
{
"bar" : "ipsum",
"foo" : "lorem"
}
Za zmínku stojí, že soubor json_pp je předinstalován s Ubuntu 12.04 (minimálně) a Debianem v souboru /usr/bin/json_pp
Doporučuji použít příkazový řádek json_xs, který je součástí modulu JSON :: XS Perl. JSON :: XS je Perl modul pro serializaci/deserializaci JSONu, na stroji Debian nebo Ubuntu jej můžete nainstalovat takto:
Sudo apt-get install libjson-xs-Perl
Je samozřejmě také k dispozici na CPAN .
Chcete-li jej použít k formátování souboru JSON získaného z adresy URL, můžete použít toto nastavení:
$ curl -s http://page.that.serves.json.com/json/ | json_xs
nebo toto:
$ wget -q -O - http://page.that.serves.json.com/json/ | json_xs
a formátovat soubor JSON obsažený v souboru:
$ json_xs < file-full-of.json
Přeformátovat jako YAML , které někteří lidé považují za lidsky čitelnější než JSON:
$ json_xs -t yaml < file-full-of.json
brew install jqcommand + | jq- (příklad:
curl localhost:5000/blocks | jq) - Užívat si!
jj je super-rychlý, dokáže ekonomicky zpracovávat ginormní dokumenty JSON, nepořádá se s platnými JSON čísly a je snadno použitelný, např.
jj -p # for reading from STDIN
nebo
jj -p -i input.json
Je to (2018) stále zcela nová, takže možná nebude pracovat s neplatným JSON tak, jak očekáváte, ale snadno se instaluje na hlavní platformy.
Nainstalujte nástroje yajl s příkazem uvedeným níže:
Sudo apt-get install yajl-tools
pak,
echo '{"foo": "lorem", "bar": "ipsum"}' | json_reformat
yajl je velmi pěkný, podle mých zkušeností. Příkaz json_reformat používám k tisku souborů .json v souboru vim zadáním následujícího řádku do souboru .vimrc:
autocmd FileType json setlocal equalprg=json_reformat
Verze PHP, pokud máte 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
Použít Ruby v jednom řádku:
echo '{"test":1,"test2":2}' | Ruby -e "require 'json'; puts JSON.pretty_generate(JSON.parse(STDIN.read))"
A pro to můžete nastavit alias:
alias to_j="Ruby -e \"require 'json';puts JSON.pretty_generate(JSON.parse(STDIN.read))\""
Pak jej můžete pohodlněji používat
echo '{"test":1,"test2":2}' | to_j
{
"test": 1,
"test2": 2
}
Pokud chcete zobrazit JSON s barvou, můžete nainstalovat soubor awesome_print,
gem install awesome_print
pak
alias to_j="Ruby -e \"require 'json';require 'awesome_print';ap JSON.parse(STDIN.read)\""
Zkus to!
echo '{"test":1,"test2":2, "arr":["aa","bb","cc"] }' | to_j
bat je klon cat se zvýrazněním syntaxe: https://github.com/sharkdp/bat
Příklad:
echo '{"bignum":1e1000}' | bat -p -l json
-p bude vystupovat bez záhlaví a -l bude výslovně specifikovat jazyk.
To má zbarvení a formátování pro json, a dělá ne mají problémy uvedené v tomto komentáři: Jak mohu docela-tisk JSON ve skriptu Shell?
Používám httpie
$ pip install httpie
A můžete ho použít takhle
$ 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
}
Vím, že tato otázka byla zodpovězena ad nauseam, ale chtěl jsem zdokumentovat řešení Ruby, které je lepší než příkaz Jtsonův prettify, klenot colorful_json je docela dobrý.
gem install colorful_json
echo '{"foo": "lorem", "bar": "ipsum"}' | cjson
{
"foo": "lorem",
"bar": "ipsum"
}
Řešení J.F. Sebastiana pro mě nefungovala v Ubuntu 8.04.
Zde je upravená verze Perlu, která pracuje se starší knihovnou 1.X JSON:
Perl -0007 -MJSON -ne 'print objToJson(jsonToObj($_, {allow_nonref=>1}), {pretty=>1}), "\n";'
echo "{ \"foo\": \"lorem\", \"bar\": \"ipsum\" }"|python -m json.tool
tento jednoduchý příkaz můžete použít k dosažení výsledku.
$ Sudo apt-get install edit-json
$ prettify_json myfile.json
Zde je návod, jak to udělat s Groovy script.
Vytvořte skript Groovy, řekněme "hezky-tisk"
#!/usr/bin/env groovy
import groovy.json.JsonOutput
System.in.withReader { println JsonOutput.prettyPrint(it.readLine()) }
Provést spustitelný skript:
chmod +x pretty-print
Nyní z příkazové řádky
echo '{"foo": "lorem", "bar": "ipsum"}' | ./pretty-print
Nástroj ydump je hezká tiskárna JSON:
$ ydump my_data.json
{
"foo": "lorem",
"bar": "ipsum"
}
Nebo můžete napojit na JSON:
$ echo '{"foo": "lorem", "bar": "ipsum"}' | ydump
{
"foo": "lorem",
"bar": "ipsum"
}
Toto je pravděpodobně nejkratší řešení kromě použití nástroje jq.
Tento nástroj je součástí knihovny yojson pro OCaml , a je dokumentován zde .
Balík libyojson-ocaml-dev obsahuje tento nástroj na Debianu a jeho derivátech. Alternativně lze yojson nainstalovat přes OPAM .
Pro Node.js můžete také použít modul "util". Využívá zvýraznění syntaxe, inteligentní odsazování, odstraňuje citace z klíčů a dělá výstup tak pěkný, jak to jen jde.
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}))}}))"
Jsem autor json-liner . Je to nástroj příkazového řádku, aby se JSON změnil na přátelský formát. Pokusit se.
$ echo '{"a": 1, "b": 2}' | json-liner
/%a 1
/%b 2
$ echo '["foo", "bar", "baz"]' | json-liner
/@0 foo
/@1 bar
/@2 baz
Pokud máte nainstalovaný Node.js, můžete si vytvořit jeden vlastní s jedním řádkem kódu. Vytvořit soubor:
> hezky
#!/usr/bin/env node
console.log(JSON.stringify(JSON.parse(process.argv[2]), null, 2));
Přidat oprávnění ke spuštění:
> chmod + x hezká
> ./pretty '{"foo": "lorem", "bar": "ipsum"}'
Nebo pokud je váš soubor JSON v souboru:
#!/usr/bin/env node
console.log(JSON.stringify(require("./" + process.argv[2]), null, 2));
> ./pretty file.json
S JavaScriptem/NodeJS: podívejte se na vkBeautify.js plugin , který poskytuje hezký tisk jak pro text JSON, tak pro XML.
Je napsán v prostém JavaScriptu, méně než 1,5 kB (minifikovaný) a velmi rychlý.
Zde je 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
Tato metoda také "Detekuje HTTP odpověď/záhlaví, tiskne je nedotčené a přeskočí na Tělo (pro použití s` curl -i ') " .
Jednořádkové řešení s použitím nodejs bude vypadat takto
$ node -e "console.log( JSON.stringify( JSON.parse(require('fs').readFileSync(0) ), 0, 1 ))"
např. pro:
$ cat test.json | node -e "console.log( JSON.stringify( JSON.parse(require('fs').readFileSync(0) ), 0, 1 ))"
Můžete použít smk :
echo '{"foo": "lorem", "bar": "ipsum"}' | smk -e"JSON.stringify(JSON.parse(data), null, 4)"
Na jednom řádku
echo '{"foo": "lorem", "bar": "ipsum"}' | npx smk -e"JSON.stringify(JSON.parse(data), null, 4)"
Pokud vám nevadí použití nástroje třetí strany, můžete jednoduše zkroutit na jsonprettyprint.org . To je případ, kdy nemůžete instalovat balíčky na stroji.
curl -XPOST https://jsonprettyprint.org/api -d '{"user" : 1}'
Také se ujistěte, podívejte se JSONFUI: příkazový řádek JSON prohlížeč, který podporuje skládání
Moje soubory JSON nebyly analyzovány žádnou z těchto metod.
Můj problém byl podobný tomuto příspěvku Google Data Source JSON není platný? .
Odpověď na tento příspěvek mi pomohla najít řešení. https://stackoverflow.com/a/628634/619760
Je považován za neplatný JSON bez řetězců.
{id:'name',label:'Name',type:'string'}
musí být:
{"id": "name", "label": "Name", "type": "string"}
Tento odkaz poskytuje pěkné komplexní srovnání některých z různých analyzátorů JSON. http://deron.meranda.us/python/comparing_json_modules/basic
Což mě vedlo k http://deron.meranda.us/python/demjson/ . Myslím, že tento parser je mnohem více tolerantnější k chybám než mnoho jiných.
Můžete použít Xidel .
Xidel je nástroj příkazového řádku ke stažení a extrahování dat z HTML/XML stránek nebo JSON-APIs, pomocí CSS, XPath 3.0, XQuery 3.0, JSONiq nebo šablony vzorů. Může také vytvářet nové nebo transformované dokumenty XML/HTML/JSON.
Standardně tiskne Xidel:
$ xidel -s - -e '$json' <<< '{"foo":"lorem","bar":"ipsum"}'
{
"foo": "lorem",
"bar": "ipsum"
}
nebo:
$ echo '{"foo":"lorem","bar":"ipsum"}' | xidel -s - -e .
{
"foo": "lorem",
"bar": "ipsum"
}