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




unix read json (20)

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

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

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