it-swarm-eu.dev

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

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

3958
B Bycroft

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"
}
766
Vita Pluvia

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

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.

podtržený-cli

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.

326
Dave Dopson

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
171
locojay

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))
85
AnC

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
69
isaacs

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").

68
knb

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.

67
Daryl Spitzer

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

64
Paul Horsfall

Není to příliš jednoduché s nativním způsobem s nástroji jq .

Například: 

cat xxx | jq .
63
Olexandr Minzak

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 | jsonpp

a 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.

53
jordelver

Zkuste pjson . Má barvy!

echo '{"json":"obj"} | pjson

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.

42
JedatKinports

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.

39
yardena

Podívejte se na Jazor . Je to jednoduchý příkazový řádek JSON parser napsaný v Ruby.

gem install jazor
jazor --help
37
Mike

Nebo s Ruby:

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

Jednoduše připojte výstup na jq ..

Příklad:

twurl -H ads-api.Twitter.com '.......' | jq .
29
Ackshaey Singh

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
28
Salman A

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
23
Evgeny Karpov

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

19
Philip Durbin

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
18
htaccess
  1. brew install jq
  2. command + | jq 
  3. (příklad: curl localhost:5000/blocks | jq)
  4. Užívat si!

 enter image description here

15

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.

14
peak

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

11
Uma sankar pradhan

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
10
Hank Gay

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
9
svidgen

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

 Enter image description here

8
fangxing

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?

8
Grav

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
 }
8
slashmili

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";'
7
pimlottc
echo "{ \"foo\": \"lorem\", \"bar\": \"ipsum\" }"|python -m json.tool

tento jednoduchý příkaz můžete použít k dosažení výsledku.

7
Arpit Rathod
$ Sudo apt-get install edit-json
$ prettify_json myfile.json
6
Bryan Larsen

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
5
numan salati

Tam je TidyJSON .

Je to C #, takže možná ho můžete zkompilovat pomocí Mono , a pracovat na * nix. Žádné záruky, promiň.

5
Robert Gould

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 .

5
josch

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}))}}))"
4
adius

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
3
Wu Yongzheng

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

3
Nikhil Ranjan

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ý.

3
vadimk

Zde je Groovy one-liner:

echo '{"foo": "lorem", "bar": "ipsum"}' | groovy -e 'import groovy.json.*; println JsonOutput.prettyPrint(System.in.text)'
2
Orest Ivasiv

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))
2
Aidan Melen
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 ') " .

2
lev

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 ))"
1
harish2704

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)"
0

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}'
0
Yada
0
chronos

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. 

0
nelaaro

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