it-swarm.dev

¿Cómo puedo imprimir JSON en un script de Shell?

¿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"
}
2828
AnC

Con Python 2.6+ simplemente 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 proviene 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 puedes hacer un alias:

alias prettyjson='python -m json.tool'

Para aún más comodidad con un poco más de escritura para prepararlo:

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 en .bashrc y estará disponible cada vez que esté en Shell. Invocarlo como prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'.

3958
B Bycroft

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

Aquí hay un ejemplo:

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

O en otras palabras:

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

Utilizo el argumento "espacio" de JSON.stringify para imprimir bastante 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 nodejs, 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, especifique un nombre de archivo que contenga JSON y use 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 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));\
 });\
"
366
Somu

Escribí una herramienta que tiene uno de los mejores formateadores de "espacios en blanco inteligentes" disponibles. Produce una salida más legible y menos detallada 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 en línea de comandos. Es una navaja suiza que utilizo para 1001 tareas pequeñas diferentes que sería sorprendentemente molesto hacer de otra manera.

Último caso de uso: Chrome, consola de desarrollo, pestaña de red, exportar todo como archivo HAR, "cat site.har | subrayado seleccionar '.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 actual de pasión, por lo que si tiene alguna solicitud de características, es muy probable que las aborde.

326
Dave Dopson

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, use curl en la línea de comandos con un token de autenticación:

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

Gracias a los consejos muy útiles de J. F. Sebastian, he aquí un script ligeramente mejorado que he encontrado:

#!/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 __== "__main__":
    sys.exit(not main(sys.argv))
85
AnC

Si usa npm y Node.js, puede hacer npm install -g json y luego canalizar el comando a través de json. Haga json -h para 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
69
isaacs

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

Validar:

json_xs -t null < myfile.json

Prettifique el archivo JSON src.json a pretty.json:

< src.json json_xs > pretty.json

Si no tiene json_xs, intente 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, "Sistema de extensión" de Perl).

68
knb

En * nix, leer desde stdin y escribir a 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 (nombré el mío "prettyJSON" después de la respuesta de AnC ) en su PATH y chmod +x it, y listo.

67
Daryl Spitzer

El JSON Ruby Gem se incluye con un script de Shell para pretender JSON:

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

Descarga del script: Gist.github.com/3738968

64
Paul Horsfall

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

Por ejemplo: 

cat xxx | jq .
63
Olexandr Minzak

ACTUALIZAREstoy usando jq ahora 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 impresionante de imprimir JSON para ver.

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

Desde el README:

Respuestas bonitas del servicio web de impresión 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 brew install jsonpp. Si no, simplemente puede copiar el binario en algún lugar de su $PATH.

53
jordelver

Intente pjson . ¡Tiene colores!

echo '{"json":"obj"} | pjson

Instálalo con pip:

⚡ pip install pjson

Y luego canaliza cualquier contenido JSON a pjson.

Así es como lo hago:

curl yourUri | json_pp

Acorta el código y hace el trabajo.

42
JedatKinports
$ 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 ejecuta

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 bien legible se convierte en codificada\u

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

Si el resto de su canalización manejará con gracia unicode y le gustaría que su JSON también sea amigable para los humanos, simplemente useensure_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á:

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

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

39
yardena

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

gem install jazor
jazor --help
37
Mike

O, con Ruby:

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

Simplemente canalice la salida a jq ..

Ejemplo:

twurl -H ads-api.Twitter.com '.......' | jq .
29
Ackshaey Singh

JSONLint tiene una implementación de código abierto en github puede usarse en la línea de comandos 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
28
Salman A

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:

Demo

24
Shubham Chaudhary

Golpe de vainilla

Un simple script Bash (grep/awk) para la impresión JSON bonita, sin instalación de terceros:

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

Ejemplos:

1) Leer archivo e impresión bonita en consola.

cat file.json | json_pretty.sh

2) Use con el GIT Bash de Windows de un archivo a otro (basado en UTF8):

cat fileIn.json |sh.exe json_pretty.sh > fileOut.json
23
Evgeny Karpov

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

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

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

19
Philip Durbin

Recomiendo usar la utilidad de línea de comandos json_xs que se incluye en el módulo JSON :: XS Perl. JSON :: XS es ​​un módulo Perl para la serialización/deserialización de 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, puedes usar curl o wget así:

$ 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 puedes hacer esto:

$ json_xs < file-full-of.json

Para reformatear como YAML , lo que algunas personas consideran más legible humanamente que JSON:

$ json_xs -t yaml < file-full-of.json
18
htaccess
  1. brew install jq
  2. command + | jq 
  3. (ejemplo: curl localhost:5000/blocks | jq)
  4. ¡Disfrutar!

 enter image description here

15
alexanderjsingleton

jj es súper rápido, puede manejar documentos JSON gigantescos de manera económica, no se mete con números JSON válidos y es fácil de usar, por ejemplo. 

jj -p # for reading from STDIN

o

jj -p -i input.json

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

14
peak

Instala yajl-tools con el siguiente comando:

Sudo apt-get install yajl-tools

entonces,

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

11
Uma sankar pradhan

yajl es muy agradable, en mi experiencia. Utilizo su comando json_reformat para imprimir bastante .json archivos en vim poniendo la siguiente línea en mi .vimrc:

autocmd FileType json setlocal equalprg=json_reformat
10
Hank Gay

La versión PHP, si tiene PHP> = 5.4.

alias prettify_json=php -E '$o = json_decode($argn); print json_encode($o, JSON_PRETTY_PRINT);'
echo '{"a":1,"b":2}' | prettify_json
9
svidgen

Usa Ruby en una línea:

echo '{"test":1,"test2":2}' | Ruby -e "require 'json'; puts JSON.pretty_generate(JSON.parse(STDIN.read))"

Y puedes establecer un alias para esto:

alias to_j="Ruby -e \"require 'json';puts JSON.pretty_generate(JSON.parse(STDIN.read))\""

Entonces puedes usarlo más convenientemente

echo '{"test":1,"test2":2}' | to_j

{
  "test": 1,
  "test2": 2
}

Y si desea visualizar JSON con color, puede instalar awesome_print,

gem install awesome_print

entonces

alias to_j="Ruby -e \"require 'json';require 'awesome_print';ap JSON.parse(STDIN.read)\""

¡Intentalo!

echo '{"test":1,"test2":2, "arr":["aa","bb","cc"] }' | to_j

 Enter image description here

8
fangxing

bat es un clon cat con resaltado de sintaxis: https://github.com/sharkdp/bat

Ejemplo:

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

-p se imprimirá sin encabezados, y -l especificará explícitamente el idioma.

Tiene coloración y formato para json, y tiene no tiene los problemas anotados en este comentario: ¿Cómo puedo imprimir en forma bonita JSON en un script de Shell?

8
Grav

Estoy usando httpie

$ pip install httpie

Y puedes usarlo así.

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

Sé que esta pregunta se ha respondido hasta el final, pero quería documentar una solución de Ruby que sea mejor que el comando de prettify de Json, la gema colorful_json es bastante buena.

gem install colorful_json
echo '{"foo": "lorem", "bar": "ipsum"}' | cjson
{
  "foo": "lorem",
  "bar": "ipsum"
}

Las soluciones de J.F. Sebastian no me funcionaron en Ubuntu 8.04.
Aquí hay una versión modificada de Perl que funciona con la antigua biblioteca JSON 1.X:

Perl -0007 -MJSON -ne 'print objToJson(jsonToObj($_, {allow_nonref=>1}), {pretty=>1}), "\n";'
7
pimlottc
echo "{ \"foo\": \"lorem\", \"bar\": \"ipsum\" }"|python -m json.tool

puedes usar este simple comando para lograr el resultado.

7
Arpit Rathod
$ Sudo apt-get install edit-json
$ prettify_json myfile.json
6
Bryan Larsen

Aquí está cómo hacerlo con Groovy script.

Crear un script Groovy, digamos "impresión bonita"

#!/usr/bin/env groovy

import groovy.json.JsonOutput

System.in.withReader { println JsonOutput.prettyPrint(it.readLine()) }

Hacer script ejecutable:

chmod +x pretty-print

Ahora desde la línea de comando,

echo '{"foo": "lorem", "bar": "ipsum"}' | ./pretty-print
5
numan salati

Hay TidyJSON .

Es C #, así que quizás puedas compilarlo con Mono , y trabajar en * nix. Sin embargo, no hay garantías, lo siento.

5
Robert Gould

La herramienta ydump es una impresora JSON:

$ ydump my_data.json
{
  "foo": "lorem",
  "bar": "ipsum"
}

O puedes canalizar en el JSON:

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

Esta es probablemente la solución más corta además de usar la herramienta jq.

Esta herramienta forma parte de la biblioteca yojson para OCaml , y está documentada aquí .

En Debian y sus derivados, el paquete libyojson-ocaml-dev contiene esta herramienta. Alternativamente, yojson se puede instalar a través de OPAM .

5
josch

Para Node.js también puede usar el módulo "util". Utiliza resaltado de sintaxis, sangría inteligente, elimina las comillas de las teclas y hace que la salida sea lo más bonita posible.

cat file.json | node -e "process.stdin.pipe(new require('stream').Writable({write: chunk =>  {console.log(require('util').inspect(JSON.parse(chunk), {depth: null, colors: true}))}}))"
4
adius

Soy el autor de json-liner . Es una herramienta de línea de comandos para convertir JSON en un formato compatible con grep. Darle una oportunidad.

$ echo '{"a": 1, "b": 2}' | json-liner
/%a 1
/%b 2
$ echo '["foo", "bar", "baz"]' | json-liner
/@0 foo
/@1 bar
/@2 baz
3
Wu Yongzheng

Si tiene instalado Node.js, puede crear uno por su cuenta con una línea de código. Crea un archivo bonito:

> Vim Pretty

#!/usr/bin/env node

console.log(JSON.stringify(JSON.parse(process.argv[2]), null, 2));

Añadir permiso de ejecución:

> chmod + x bonita

> ./pretty '{"foo": "lorem", "bar": "ipsum"}'

O si tu JSON está en un archivo:

#!/usr/bin/env node

console.log(JSON.stringify(require("./" + process.argv[2]), null, 2));

> ./pretty file.json

3
Nikhil Ranjan

Con JavaScript/NodeJS: eche un vistazo al plugin vkBeautify.js , que proporciona una buena impresión tanto para texto JSON como XML.

Está escrito en JavaScript simple, menos de 1.5 KB (minificado) y muy rápido.

3
vadimk

Aquí está Groovy de una sola línea:

echo '{"foo": "lorem", "bar": "ipsum"}' | groovy -e 'import groovy.json.*; println JsonOutput.prettyPrint(System.in.text)'
2
Orest Ivasiv

https://github.com/aidanmelen/json_pretty_print

from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division

import json
import jsonschema

def _validate(data):
    schema = {"$schema": "http://json-schema.org/draft-04/schema#"}
    try:
        jsonschema.validate(data, schema,
                            format_checker=jsonschema.FormatChecker())
    except jsonschema.exceptions.ValidationError as ve:
        sys.stderr.write("Whoops, the data you provided does not seem to be " \
        "valid JSON.\n{}".format(ve))

def pprint(data, python_obj=False, **kwargs):
    _validate(data)
    kwargs["indent"] = kwargs.get("indent", 4)
    pretty_data = json.dumps(data, **kwargs)
    if python_obj:
        print(pretty_data)
    else:
       repls = (("u'",'"'),
                ("'",'"'),
                ("None",'null'),
                ("True",'true'),
                ("False",'false'))
    print(reduce(lambda a, kv: a.replace(*kv), repls, pretty_data))
2
Aidan Melen
gem install jsonpretty
echo '{"foo": "lorem", "bar": "ipsum"}' | jsonpretty

Este método también " Detecta respuestas/encabezados HTTP, los imprime sin tocar y salta a El cuerpo (para usar con` curl -i ') " .

2
lev

Una solución de una línea que utiliza nodejs se verá así

$ node -e "console.log( JSON.stringify( JSON.parse(require('fs').readFileSync(0) ), 0, 1 ))"

por ejemplo:

$ cat test.json | node -e "console.log( JSON.stringify( JSON.parse(require('fs').readFileSync(0) ), 0, 1 ))"
1
harish2704

Puedes usar smk :

echo '{"foo": "lorem", "bar": "ipsum"}' | smk -e"JSON.stringify(JSON.parse(data), null, 4)"

En una linea

echo '{"foo": "lorem", "bar": "ipsum"}' | npx smk -e"JSON.stringify(JSON.parse(data), null, 4)"
1
Thilina Hasantha

Si no le importa usar una herramienta de terceros, simplemente puede hacer curl a jsonprettyprint.org . Esto es para el caso en el que no puede instalar paquetes en la máquina.

curl -XPOST https://jsonprettyprint.org/api -d '{"user" : 1}'
0
Yada
0
chronos

Mis archivos JSON no fueron analizados por ninguno de estos métodos. 

Mi problema fue similar a este post ¿Google Data Source JSON no es válido? .

La respuesta a ese post me ayudó a encontrar una solución. https://stackoverflow.com/a/628634/619760

Se considera JSON no válido sin las claves de cadena.

{id:'name',label:'Name',type:'string'}

debe ser:

{"id": "name", "label": "Name", "type": "string"}

Este enlace ofrece una comparación completa de Niza de algunos de los diferentes analizadores JSON. http://deron.meranda.us/python/comparing_json_modules/basic

Lo que me llevó a http://deron.meranda.us/python/demjson/ . Creo que este analizador es mucho más tolerante a fallas que muchos otros. 

0
nelaaro

Puedes usar Xidel

Xidel es una herramienta de línea de comandos para descargar y extraer datos de páginas HTML/XML o API de JSON, utilizando CSS, XPath 3.0, XQuery 3.0, JSONiq o plantillas de patrones. También puede crear documentos XML/HTML/JSON nuevos o transformados.

Xidel imprime de forma predeterminada:

$ xidel -s - -e '$json' <<< '{"foo":"lorem","bar":"ipsum"}'
{
  "foo": "lorem",
  "bar": "ipsum"
}

o:

$ echo '{"foo":"lorem","bar":"ipsum"}' | xidel -s - -e .
{
  "foo": "lorem",
  "bar": "ipsum"
}
0
Reino