read - Come posso stampare abbastanza JSON in uno script di shell(Unix)?




unix read json (20)

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

Fondamentalmente, voglio che trasformi il seguente:

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

... in qualcosa di simile:

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

Vanilla Bash

Un semplice script Bash ( grep / awk ) per una bella stampa JSON, senza installazione di terze parti:

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

Esempi:

1) Leggi file e bella stampa in console

cat file.json | json_pretty.sh

2) Utilizzare con Windows GIT Bash da file a file (basato su UTF8):

cat fileIn.json |sh.exe json_pretty.sh > fileOut.json

pygmentize

Combino Python's json.tool con pygmentize:

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

Ci sono alcune alternative a Pygmentize che sono elencate nella mia questa risposta .

Ecco una demo dal vivo:


Basta inviare 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' example di B Bycroft ottieni:

[[email protected] ~]$ echo '{"foo": "lorem", "bar": "ipsum"}' | json_pp
{
   "bar" : "ipsum",
   "foo" : "lorem"
}

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


Con Python 2.6+ puoi semplicemente:

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

oppure, se il JSON è in un file, puoi fare:

python -m json.tool my_json.json

se il JSON proviene da una fonte internet come un'API, puoi usare

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

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

alias prettyjson='python -m json.tool'

Per ancora più comodità con un po 'più di digitazione per averlo pronto:

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 metterlo in .bashrc e sarà disponibile ogni volta nella shell. Richiamalo come prettyjson_s '{"foo": "lorem", "bar": "ipsum"}' .


Di solito faccio solo:

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

E per recuperare i dati selezionati (in questo caso, il valore di "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 curl sulla riga di comando usando un token di autenticazione:

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

Grazie agli indicatori molto utili di JF Sebastian, ecco una sceneggiatura leggermente migliorata che ho trovato:

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

Ho scritto uno strumento che ha uno dei migliori formattatori di "spazio bianco intelligente" disponibile. Produce un output più leggibile e meno dettagliato rispetto alla maggior parte delle altre opzioni qui.

underscore-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. E 'super-friendly da usare e ha una guida / documentazione di riga di comando estesa. È un coltellino svizzero che uso per 1001 piccoli compiti diversi che sarebbero sorprendentemente fastidiosi di fare qualsiasi altra cosa.

Ultimo caso d'uso: Chrome, console di sviluppo, scheda Rete, esportazione tutto come file HAR, "cat site.har | underscore select" .url "--outfmt text | grep mydomain"; ora ho una lista cronologicamente ordinata di tutti i recuperi di URL effettuati durante il caricamento del sito della mia azienda.

La stampa carina è facile:

underscore -i data.json print

Stessa cosa:

cat data.json | underscore print

La stessa cosa, più esplicita:

cat data.json | underscore print --outfmt pretty

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


Io uso jshon per fare esattamente quello che stai descrivendo. Corri:

echo $COMPACTED_JSON_TEXT | jshon

È anche possibile passare argomenti per trasformare i dati JSON.


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

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

Download di script: gist.github.com/3738968


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

Per esempio:

cat xxx | jq .

Oppure, con Ruby:

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

Puoi usare: jq

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

Ecco un esempio:

$ jq . <<< '{ "foo": "lorem", "bar": "ipsum" }'
{
  "bar": "ipsum",
  "foo": "lorem"
}

O in altre parole:

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

Raccomando di usare l'utilità della riga di comando json_xs che è 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 farlo:

$ json_xs < file-full-of.json

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

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

Sto usando httpie

$ pip install httpie

E puoi usarlo in questo modo

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

Su * nix, la lettura da stdin e la scrittura su stdout funzionano 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 PATH e chmod +x it, e sei a posto.


JSONLint ha JSONLint open-source su github può essere usato sulla riga di comando o incluso 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

yajl è molto carino, secondo la mia esperienza. Io uso il suo comando json_reformat per stampare abbastanza .json file in vim inserendo la seguente riga nel mio .vimrc :

autocmd FileType json setlocal equalprg=json_reformat

jj è super veloce, può gestire i documenti JSON ginormous in modo economico, non ha problemi con i 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 invalido come previsto, ma è facile da installare sulle piattaforme principali.


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

jsonpp è una bella stampante JSON piuttosto bella da riga di comando.

Dal README:

Le risposte al servizio web di stampa sono piuttosto simili:

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

e rendi belli i file che girano sul tuo disco:

jsonpp data/long_malformed.json

Se utilizzi Mac OS X, puoi brew install jsonpp . In caso contrario, puoi semplicemente copiare il file binario in qualche punto del tuo $PATH .







pretty-print