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

Prefiero python -m json.tool que 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 que es o puede ser una buena cosa en donde el json fue generado por algún lenguaje que usó HashMaps desordenados...

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

Http://stedolan.github.com/jq/

Desde el sitio web:

Jq es como sed para datos JSON - se puede utilizar para segmentar y filtrar y mapa y transformar datos estructurados con la misma facilidad que sed, awk, grep y amigos vamos a jugar con el texto.

Jq puede destrozar el formato de datos en el que desea con muy poco esfuerzo, y el programa para hacerlo es a menudo más corto y más 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 en línea de comandos:

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

• FLEXIBLE - LA herramienta "swiss-army-knife" para el procesamiento de datos JSON - se puede utilizar como una simple pretty-printer, o como una línea de comandos Javascript completa
• POTENTE - Expone toda la potencia y funcionalidad de underscore.js (plus underscore.string)
• SIMPLE - Lo hace simple para escribir JS one-liners similares a usar "perl-pe"
• ENCADENADO - Múltiples invocaciones de comandos se pueden encadenar juntas para crear una canalización de procesamiento de datos
• MULTIFORMATO - Soporte rico para formatos de entrada / salida - pretty-printing, strict JSON, etc [próximamente]
• DOCUMENTED - Excelente documentación de línea de comandos con múltiples ejemplos para cada comando

Te permite hacer cosas poderosas realmente fácilmente:

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" smart-whitespace " disponibles:

Si tienes alguna solicitud de característica, comenta en esta publicación o agrega un problema en github. Me encantaría priorizar las características que necesitan los miembros de la comunidad.

Checkout TickTick.

Es un verdadero analizador de 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 existe JSON command line processing toolkit si tiene node.js y npm en tu pila.

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

Y aquí están las otras alternativas:

• jq: http://stedolan.github.io/jq /
• json: select: http://jsonselect.org /
• json-comando: 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 comandos para analizar entradas JSON para Unix?

Alguien mencionó Jshon o JSON.sh?

Https://github.com/keenerd/jshon

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

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

Usted podría intentar jsawk como se sugiere en esta respuesta.

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

Para Bash / Python , aquí hay un envoltorio 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 diccionario anidado de datos, pero funciona para lo que necesitaba, y es útil para caminar a través del json. Probablemente podría adaptarse al gusto.

De todos modos, algo de cosecha propia para aquellos que no quieren fuente en otra dependencia externa. Excepto Python, por supuesto.

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

Acabo de crear jkid que es un pequeño explorador json de línea de comandos que hice para explorar fácilmente objetos json grandes. Los objetos se pueden explorar " transversalmente "y hay 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"
}