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


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

2500


origine


risposte:


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


3733



Puoi usare: jq

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

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

687



Uso l'argomento "spazio" di JSON.stringify per stampare abbastanza 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 nodejs, 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 utilizzando un rientro di quattro spazi:

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

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

358



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.

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


321



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 utilizzando un token di autenticazione:

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

168



Grazie agli spunti molto utili di J.F. 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))

82



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 AnCla risposta) nel tuo PERCORSO e chmod +x e tu sei bello andare.


66



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

Convalidare:

json_xs -t null < myfile.json

Prifica il file JSON src.jsona pretty.json:

< src.json json_xs > pretty.json

Se non lo hai json_xs, provare json_pp . "pp" è per "puro perl" - lo strumento è implementato solo in Perl, senza un binding a una libreria C esterna (che è ciò che XS rappresenta, "Extension System" di Perl).


65