¿Existe un script de shell (Unix) para formatear JSON en forma legible para humanos?

Básicamente, quiero que transforme lo siguiente:

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

... en algo como esto:

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

Con Python 2.6+ solo puedes hacer:

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

o, si el JSON está en un archivo, puede hacer:

python -m json.tool my_json.json

si el JSON es de una fuente de internet como una API, puede usar

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

Para mayor comodidad en todos estos casos, puede hacer un alias:

alias prettyjson='python -m json.tool'

Para una mayor comodidad con un poco más de mecanografía para tenerlo listo:

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

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

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

para todos los casos anteriores Puede poner esto .bashrcy estará disponible cada vez en shell. Invocarlo como prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'.

Puedes usar: jq

¡Es muy simple de usar y funciona muy bien! Puede manejar estructuras JSON muy grandes, incluidas las secuencias. Puedes encontrar sus tutoriales aquí .

Ejemplos de uso:

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

Los . es el filtro de identidad

Utilizo el argumento "espacio" JSON.stringifypara imprimir JSON en JavaScript.

Ejemplos:

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

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

Desde la línea de comandos de Unix con Node.js, especificando JSON en la línea de comandos:

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

Devoluciones:

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

Desde la línea de comandos de Unix con Node.js, especificando un nombre de archivo que contiene JSON y usando una sangría de cuatro espacios:

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

Usando una tubería:

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

Escribí una herramienta que tiene uno de los mejores formateadores de "espacios en blanco inteligentes" disponibles. Produce resultados más legibles y menos detallados que la mayoría de las otras opciones aquí.

subrayado-cli

Así es como se ve el "espacio en blanco inteligente":

Puede que esté un poco sesgado, pero es una herramienta increíble para imprimir y manipular datos JSON desde la línea de comandos. Es muy fácil de usar y tiene una amplia ayuda / documentación de línea de comandos. Es una navaja suiza que uso para 1001 pequeñas tareas diferentes que serían sorprendentemente molestas de hacer de otra manera.

Último caso de uso: Chrome, Consola de desarrollo, pestaña Red, exportar todo como archivo HAR, "cat site.har | subrayado seleccione '.url' --outfmt text | grep mydomain"; ahora tengo una lista ordenada cronológicamente de todas las recuperaciones de URL realizadas durante la carga del sitio de mi empresa.

La impresión bonita es fácil:

underscore -i data.json print

La misma cosa:

cat data.json | underscore print

Lo mismo, más explícito:

cat data.json | underscore print --outfmt pretty

Esta herramienta es mi proyecto de pasión actual, por lo que si tiene alguna solicitud de función, es muy probable que la aborde.

Usualmente solo hago:

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

Y para recuperar datos seleccionados (en este caso, el valor de "prueba"):

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

Si los datos JSON están en un archivo:

python -mjson.tool filename.json

Si desea hacerlo todo de una vez, vaya curla la línea de comandos utilizando un token de autenticación:

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

Gracias a los útiles consejos de JF Sebastian, aquí hay un script ligeramente mejorado que se me ocurrió:

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

Si usa npm y Node.js, puede hacerlo npm install -g jsony luego canalizar el comando json. Haz json -hpara obtener todas las opciones. También puede extraer campos específicos y colorear la salida con -i.

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

No es demasiado simple con una forma nativa con las herramientas jq .

Por ejemplo:

cat xxx | jq .

Con Perl, use el módulo CPAN JSON::XS. Instala una herramienta de línea de comando json_xs.

Validar:

json_xs -t null < myfile.json

Prettifique el archivo JSON src.jsonpara pretty.json:

< src.json json_xs > pretty.json

Si no tienes json_xs, inténtalo json_pp. "pp" es para "perl puro": la herramienta se implementa solo en Perl, sin un enlace a una biblioteca C externa (que es lo que significa XS, el "Sistema de extensión" de Perl).

En * nix, leer desde stdin y escribir en stdout funciona mejor:

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

Ponga esto en un archivo (llamé al mío "prettyJSON" después de la respuesta de AnC ) en su RUTA y chmod +xlisto, y listo.

JSON Ruby Gem se incluye con un script de shell para embellecer JSON:

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

Descarga del script: gist.github.com/3738968

ACTUALIZACIÓN Estoy usando jqahora como se sugiere en otra respuesta. Es extremadamente poderoso para filtrar JSON, pero, en su forma más básica, también es una forma increíble de imprimir JSON para verlo.

jsonpp es una bonita impresora JSON de línea de comandos muy bonita.

Desde el archivo Léame:

Respuestas de servicio web bastante impresas así:

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

y embellece los archivos que se ejecutan en tu disco:

jsonpp data/long_malformed.json

Si estás en Mac OS X, puedes hacerlo brew install jsonpp. Si no, simplemente puede copiar el binario en algún lugar de su $PATH.

Así es como lo hago:

curl yourUri | json_pp

Acorta el código y hace el trabajo.

un script bash simple para una bonita impresión 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}'

Ejemplo:

cat file.json | json_pretty.sh

Tratar pjson. Tiene colores!

Instalarlo con pip:

⚡ pip install pjson

Y luego canalice cualquier contenido 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: No es la forma de hacerlo.

Lo mismo en Perl:

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

Nota 2: si corres

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 palabra agradablemente legible se codifica

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

Si el resto de su canalización manejará con gracia Unicode y desea que su JSON también sea amigable para los humanos, simplemente use 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)'

y obtendrás:

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

Yo uso jshon para hacer exactamente lo que estás describiendo. Solo corre:

echo $COMPACTED_JSON_TEXT | jshon

También puede pasar argumentos para transformar los datos JSON.

O con Ruby:

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

Echa un vistazo a Jazor . Es un analizador JSON de línea de comando simple escrito en Ruby.

gem install jazor
jazor --help

Puede usar este comando simple para lograr el resultado:

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

JSONLint tiene una implementación de código abierto en GitHub que puede usarse en la línea de comando o incluirse en un proyecto Node.js.

npm install jsonlint -g

y entonces

jsonlint -p myfile.json

o

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

Simplemente canalice la salida a jq ..

Ejemplo:

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

Con Perl, si instala JSON :: PP desde CPAN obtendrá el comando json_pp . Robando el ejemplo de B Bycroft obtienes:

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

Vale la pena mencionar que json_ppviene preinstalado con Ubuntu 12.04 (al menos) y Debian en/usr/bin/json_pp

Pygmentize

Combino json.tool de Python con pygmentize:

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

Hay algunas alternativas a pygmentize que se enumeran en mi esta respuesta .

Aquí hay una demostración en vivo:

Recomiendo usar la utilidad de línea de comandos json_xs que se incluye en el módulo perl JSON :: XS. JSON :: XS es ​​un módulo Perl para serializar / deserializar JSON, en una máquina Debian o Ubuntu puede instalarlo así:

sudo apt-get install libjson-xs-perl

Obviamente también está disponible en CPAN .

Para usarlo para formatear JSON obtenido de una URL, puede usar curl o wget de esta manera:

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

o esto:

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

y para formatear JSON contenido en un archivo puede hacer esto:

$ json_xs < file-full-of.json

Para formatear como YAML , que algunas personas consideran más legible para los humanos que JSON:

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

Simplemente puede usar herramientas estándar como jq o json_pp.

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

o

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

ambos embellecerán la salida como la siguiente (jq aún más colorida)

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

La gran ventaja de jq es que puede hacer MUCHO más si desea analizar y procesar el json.

jj es súper rápido, puede manejar documentos JSON descomunales de forma económica, no se mete con números JSON válidos y es fácil de usar, p. ej.

jj -p # for reading from STDIN

o

jj -p -i input.json

Es (2018) todavía bastante nuevo, por lo que tal vez no manejará JSON no válidos de la manera que espera, pero es fácil de instalar en las principales plataformas.

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

bates un catclon con resaltado de sintaxis:

Ejemplo:

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

-psaldrá sin encabezados y -lespecificará explícitamente el idioma.

Tiene colores y formatos para JSON y no tiene los problemas señalados en este comentario: ¿Cómo puedo imprimir JSON en un script de shell?

Instala yajl-tools con el siguiente comando:

sudo apt-get install yajl-tools

entonces,

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