Esiste uno script di shell (Unix) per formattare JSON in forma leggibile dall'uomo?

Fondamentalmente, voglio che trasformi quanto segue:

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

... in qualcosa del genere:

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

Con Python 2.6+ puoi semplicemente fare:

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

oppure, se JSON si trova in un file, è possibile eseguire:

python -m json.tool my_json.json

se JSON proviene da una fonte Internet come un'API, è possibile utilizzare

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

Per comodità in tutti questi casi puoi creare un alias:

alias prettyjson='python -m json.tool'

Per una comodità ancora maggiore con un po 'più di digitazione per prepararlo:

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

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

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

per tutti i casi di cui sopra. Puoi inserirlo .bashrce sarà disponibile ogni volta nella shell. Invocalo come prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'.

Puoi usare: jq

È molto semplice da usare e funziona benissimo! Può gestire strutture JSON molto grandi, inclusi i flussi. Puoi trovare i loro tutorial qui .

Esempi di utilizzo:

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

Il . è il filtro identità.

Uso l'argomento "spazio" JSON.stringifyper stampare graziosamente JSON in JavaScript.

Esempi:

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

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

Dalla riga di comando Unix con Node.js, specificando JSON sulla riga di comando:

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

Ritorna:

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

Dalla riga di comando Unix con Node.js, specificando un nome file che contiene JSON e usando un rientro di quattro spazi:

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

Usando una pipa:

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

Ho scritto uno strumento che ha uno dei migliori formattatori di "spazi bianchi intelligenti" disponibili. Produce un output più leggibile e meno dettagliato rispetto alla maggior parte delle altre opzioni qui.

sottolineatura-cli

Ecco come appare lo "spazio bianco intelligente":

Potrei essere un po 'di parte, ma è uno strumento fantastico per stampare e manipolare i dati JSON dalla riga di comando. È super-facile da usare e ha una vasta guida / documentazione da riga di comando. È un coltellino svizzero che uso per 1001 diversi piccoli compiti che sarebbero sorprendentemente fastidiosi di fare diversamente.

Caso d'uso più recente: Chrome, console di sviluppo, scheda Rete, esporta tutto come file HAR, "cat site.har | carattere di sottolineatura seleziona '.url' --outfmt text | grep mydomain"; ora ho un elenco ordinato cronologicamente di tutti i recuperi di URL effettuati durante il caricamento del sito della mia azienda.

La stampa graziosa è facile:

underscore -i data.json print

Stessa cosa:

cat data.json | underscore print

Stessa cosa, più esplicita:

cat data.json | underscore print --outfmt pretty

Questo strumento è il mio attuale progetto di passione, quindi se hai delle richieste di funzionalità, ci sono buone probabilità che le indirizzerò.

Di solito faccio solo:

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

E per recuperare i dati selezionati (in questo caso, il valore "test"):

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

Se i dati JSON sono in un file:

python -mjson.tool filename.json

Se vuoi fare tutto in una volta con curlsulla riga di comando usando un token di autenticazione:

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

Grazie ai consigli molto utili di JF Sebastian, ecco uno script leggermente migliorato che ho ideato:

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

Se si utilizza npm e Node.js, è possibile eseguire npm install -g jsone reindirizzare il comando json. Fai json -hper avere tutte le opzioni. Può anche estrarre campi specifici e colorare l'output con -i.

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

Non è troppo semplice con un modo nativo con gli strumenti jq .

Per esempio:

cat xxx | jq .

Con Perl, utilizzare il modulo CPAN JSON::XS. Installa uno strumento da riga di comando json_xs.

Convalidare:

json_xs -t null < myfile.json

Prettify il file JSON src.jsonper pretty.json:

< src.json json_xs > pretty.json

Se non lo hai json_xs, prova json_pp. "pp" sta per "puro perl" - lo strumento è implementato solo in Perl, senza un legame con una libreria C esterna (che è ciò che XS sta per "Sistema di estensione" di Perl).

Su * nix, leggere da stdin e scrivere su stdout funziona meglio:

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

Metti questo in un file (ho chiamato il mio "prettyJSON" dopo la risposta di AnC ) nel tuo PERCORSO ed chmod +xesso, e sei a posto.

JSON Ruby Gem è fornito in bundle con uno script shell per preimpostare JSON:

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

Download dello script: gist.github.com/3738968

AGGIORNAMENTO Sto usando jqora come suggerito in un'altra risposta. È estremamente potente nel filtrare JSON, ma, nella sua forma più semplice, è anche un modo fantastico per stampare JSON per la visualizzazione.

jsonpp è una bella stampante JSON da riga di comando molto carina.

Dal README:

Le risposte dei servizi Web piuttosto stampate in questo modo:

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

e rendi belli i file che girano sul tuo disco:

jsonpp data/long_malformed.json

Se sei su Mac OS X, puoi farlo brew install jsonpp. In caso contrario, puoi semplicemente copiare il file binario in un punto qualsiasi del tuo $PATH.

Ecco come lo faccio:

curl yourUri | json_pp

Riduce il codice e porta a termine il lavoro.

un semplice script bash per la stampa piuttosto 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}'

Esempio:

cat file.json | json_pretty.sh

Prova pjson. Ha dei colori!

Installalo con pip:

⚡ pip install pjson

E quindi reindirizzare qualsiasi contenuto JSON a 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"
}

NOTA: non è il modo di farlo.

Lo stesso in Perl:

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

Nota 2: se corri

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

la parola ben leggibile diventa \ u codificata

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

Se il resto della tua pipeline gestirà con grazia unicode e desideri che anche il tuo JSON sia a misura d'uomo, utilizza semplicemente 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)'

e otterrai:

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

Uso jshon per fare esattamente quello che stai descrivendo. Corri:

echo $COMPACTED_JSON_TEXT | jshon

È inoltre possibile passare argomenti per trasformare i dati JSON.

Oppure, con Ruby:

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

Dai un'occhiata a Jazor . È un semplice parser JSON da riga di comando scritto in Ruby.

gem install jazor
jazor --help

È possibile utilizzare questo semplice comando per ottenere il risultato:

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

JSONLint ha un'implementazione open source su GitHub che può essere utilizzata dalla riga di comando o inclusa in un progetto Node.js.

npm install jsonlint -g

e poi

jsonlint -p myfile.json

o

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

Semplicemente reindirizza l'output a jq ..

Esempio:

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

Con Perl, se installi JSON :: PP da CPAN otterrai il comando json_pp . Rubando l' esempio da B Bycroft ottieni:

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

Vale la pena ricordare che json_ppviene preinstallato con Ubuntu 12.04 (almeno) e Debian in/usr/bin/json_pp

pygmentize

Combino json.tool di Python con pygmentize:

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

Ci sono alcune alternative a pygmentize che sono elencate nella mia risposta .

Ecco una demo live:

Consiglio di utilizzare l'utilità della riga di comando json_xs inclusa nel modulo perl JSON :: XS. JSON :: XS è un modulo Perl per serializzare / deserializzare JSON, su una macchina Debian o Ubuntu puoi installarlo in questo modo:

sudo apt-get install libjson-xs-perl

È ovviamente disponibile anche su CPAN .

Per usarlo per formattare JSON ottenuto da un URL puoi usare curl o wget in questo modo:

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

o questo:

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

e per formattare JSON contenuto in un file puoi fare questo:

$ json_xs < file-full-of.json

Per riformattare come YAML , che alcune persone considerano più leggibile umanamente di JSON:

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

Puoi semplicemente usare strumenti standard come jq o json_pp.

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

o

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

prettificheranno entrambi l'output come il seguente (jq ancora più colorato):

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

L'enorme vantaggio di jq è che può fare MOLTO di più se desideri analizzare ed elaborare il json.

jj è superveloce, è in grado di gestire economicamente enormi documenti JSON, non scherza con numeri JSON validi ed è facile da usare, ad es.

jj -p # for reading from STDIN

o

jj -p -i input.json

È (2018) ancora abbastanza nuovo, quindi forse non gestirà JSON non valido nel modo previsto, ma è facile da installare su piattaforme principali.

1. brew install jq
2. command + | jq
3. (esempio curl localhost:5000/blocks | jq:)
4. Godere!

batè un catclone con evidenziazione della sintassi:

Esempio:

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

-pprodurrà senza intestazioni e -lspecificherà esplicitamente la lingua.

Ha colorazione e formattazione per JSON e non presenta i problemi indicati in questo commento: Come posso stampare graziosamente JSON in uno script di shell?

Installa yajl-tools con il seguente comando:

sudo apt-get install yajl-tools

poi,

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