Analizador JSON de línea de comandos de Unix? [cerrado]

¿Alguien puede recomendar un analizador JSON Unix (elija su sabor) que podría usarse para introspectar valores de una respuesta JSON en una tubería?

Puede usar este analizador de línea de comandos (que podría poner en un alias bash si lo desea), usando módulos integrados en el núcleo de Perl:

perl -MData::Dumper -MJSON::PP=from_json -ne'print Dumper(from_json($_))'

Prefiero python -m json.toolque parece estar disponible por defecto en la mayoría de los sistemas operativos * nix por defecto.

$ echo '{"foo":1, "bar":2}' | python -m json.tool
{
    "bar": 2, 
    "foo": 1
}

Pero debe tenerse en cuenta que esto ordenará todas las claves alfabéticamente, lo cual es o puede ser algo bueno en donde el json fue generado por algún lenguaje que usaba HashMaps desordenados ...

Si está buscando una herramienta compilada C portátil:

http://stedolan.github.com/jq/

Desde el sitio web:

jq es como sed para datos JSON: puede usarlo para cortar, filtrar, mapear y transformar datos estructurados con la misma facilidad que sed , awk , grep y amigos le permiten jugar con texto.

jq puede alterar el formato de datos que tiene en el que desea con muy poco esfuerzo, y el programa para hacerlo a menudo es más corto y simple de lo que cabría esperar.

Tutorial : http://stedolan.github.com/jq/tutorial/
Manual : http://stedolan.github.com/jq/manual/
Descargar : http://stedolan.github.com/jq/download/

He creado un módulo diseñado específicamente para la manipulación JSON de línea de comandos:

https://github.com/ddopson/underscore-cli

• FLEXIBLE - LA herramienta "navaja suiza" para procesar datos JSON - se puede utilizar como una simple impresora bonita o como una línea de comandos Javascript con plena potencia
• POTENTE : expone toda la potencia y funcionalidad de underscore.js (más underscore.string)
• SIMPLE : simplifica la escritura de líneas simples JS similares al uso de "perl -pe"
• EN CADENA: se pueden encadenar varias invocaciones de comandos para crear una tubería de procesamiento de datos
• MULTIFORMATO : soporte completo para formatos de entrada / salida: impresión bonita, JSON estricto, etc. [próximamente]
• DOCUMENTADO : excelente documentación de línea de comandos con múltiples ejemplos para cada comando

Te permite hacer cosas poderosas con mucha facilidad:

cat earthporn.json | underscore select '.data .title'
# [ 'Fjaðrárgljúfur canyon, Iceland [OC] [683x1024]',
#   'New town, Edinburgh, Scotland [4320 x 3240]',
#   'Sunrise in Bryce Canyon, UT [1120x700] [OC]',
# ...
#   'Kariega Game Reserve, South Africa [3584x2688]',
#   'Valle de la Luna, Chile [OS] [1024x683]',
#   'Frosted trees after a snowstorm in Laax, Switzerland [OC] [1072x712]' ]

cat earthporn.json | underscore select '.data .title' | underscore count
# 25

underscore map --data '[1, 2, 3, 4]' 'value+1'
# prints: [ 2, 3, 4, 5 ]

underscore map --data '{"a": [1, 4], "b": [2, 8]}' '_.max(value)'
# [ 4, 8 ]

echo '{"foo":1, "bar":2}' | underscore map -q 'console.log("key = ", key)'
# key = foo
# key = bar

underscore pluck --data "[{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}]" name
# [ 'moe', 'larry', 'curly' ]

underscore keys --data '{name : "larry", age : 50}'
# [ 'name', 'age' ]

underscore reduce --data '[1, 2, 3, 4]' 'total+value'
# 10

Y tiene uno de los mejores formateadores JSON de "espacio en blanco inteligente" disponibles:

Si tiene alguna solicitud de función, comente esta publicación o agregue un problema en github. Me gustaría priorizar las funciones que necesitan los miembros de la comunidad.

Checkout TickTick .

Es un verdadero analizador Bash JSON.

#!/bin/bash
. /path/to/ticktick.sh

# File
DATA=`cat data.json`
# cURL
#DATA=`curl http://foobar3000.com/echo/request.json`

tickParse "$DATA"

echo ``pathname``
echo ``headers["user-agent"]``

También hay kit de herramientas de procesamiento de línea de comandos JSON si tiene node.js y npm en su pila.

Y otro comando "json" para masajear JSON en su línea de comando Unix.

Y aquí están las otras alternativas:

• jq: http://stedolan.github.io/jq/
• fx: https://github.com/antonmedv/fx
• json: seleccione: https://github.com/dominictarr/json-select
• comando json: https://github.com/zpoley/json-command
• JSONPath: http://goessner.net/articles/JsonPath/ , http://code.google.com/p/jsonpath/wiki/Javascript
• jsawk: https://github.com/micha/jsawk
• jshon: http://kmkeen.com/jshon/
• json2: https://github.com/vi/json2

Relacionado: ¿ Herramienta de línea de comando para analizar la entrada JSON para Unix?

¿Alguien mencionó Jshon o JSON.sh?

https://github.com/keenerd/jshon

canalice json hacia él, y atraviesa los objetos json e imprime la ruta al objeto actual (como una matriz JSON) y luego el objeto, sin espacios en blanco.

http://kmkeen.com/jshon/
Jshon carga el texto json de stdin, realiza acciones, luego muestra la última acción en stdout y también se hizo parte de la canalización de procesamiento de texto habitual.

Puede probar jsawk como se sugiere en esta respuesta .

Realmente podrías crear un script de Python rápido para hacer esto.

Para Bash / Python , aquí hay un contenedor básico alrededor de Python simplejson:

json_parser() {
    local jsonfile="my_json_file.json"
    local tc="import simplejson,sys; myjsonstr=sys.stdin.read(); "`
            `"myjson=simplejson.loads(myjsonstr);"
    # Build python print command based on $@
    local printcmd="print myjson"
    for (( argn=1; argn<=$#; argn++ )); do
        printcmd="$printcmd['${!argn}']"
    done
    local result=$(python -c "$tc $printcmd.keys()" <$jsonfile 2>/dev/null \
        || python -c "$tc $printcmd" <$jsonfile 2>/dev/null)
    # For returning space-separated values
    echo $result|sed -e "s/[]|[|,|']//g"
    #echo $result 
}

Realmente solo maneja el estilo de datos de diccionario anidado, pero funciona para lo que necesitaba, y es útil para recorrer el json. Probablemente podría adaptarse al gusto.

De todos modos, algo de cosecha propia para aquellos que no desean obtener otra dependencia externa. Excepto por python, por supuesto.

Ex. json_parser {field1} {field2}correría print myjson['{field1}']['{field2}'], produciendo las claves o los valores asociados con {field2}, separados por espacios.

Acabo de hacer jkid, que es un pequeño explorador json de línea de comandos que hice para explorar fácilmente grandes objetos json. Los objetos se pueden explorar "transversalmente" y existe una opción de "vista previa" para evitar el desbordamiento de la consola.

$  echo '{"john":{"size":20, "eyes":"green"}, "bob":{"size":30, "eyes":"brown"}}' > test3.json
$  jkid . eyes test3.json 
object[.]["eyes"]
{
  "bob": "brown", 
  "john": "green"
}