Analizador JSON de la línea de comandos Unix?

Question

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

Answer 1

En primer lugar, instale el módulo de JSON de CPAN:

cpan JSON 

continuación, puede utilizar este analizador de línea de comandos (que se puede poner en un alias de bash si se quiere):

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

Answer 2

Puede probar jsawk como se sugiere en this answer.

Sin embargo, usted podría preparar un script de Python rápido para hacer esto.

Answer 3

También existe JSON command line processing toolkit si tiene node.js y npm en su pila.

Y otra "json" command para masajear JSON en su línea de comandos de Unix.

Y aquí están las otras alternativas:

• JQ: http://stedolan.github.io/jq/
• JSON: seleccione: 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

---

relacionadas: Command line tool for parsing JSON input for Unix?

Answer 4

Pedido 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"]`` 

Answer 5

¿Alguien mencionó a Jshon o JSON.sh?

https://github.com/keenerd/jshon

json tubo a ella, y que atraviesa los objetos JSON e imprime la ruta de acceso al objeto actual (como una matriz JSON) y luego el objeto, sin espacios en blanco.

http://kmkeen.com/jshon/
cargas Jshon texto JSON de la entrada estándar, lleva a cabo acciones, a continuación, muestra la última acción en la salida estándar y también fue hecho para ser parte de la canalización de procesamiento de texto habitual.

Answer 6

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

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

• FLEXIBLE - la función "suizo-ejército-cuchillo" para el procesamiento de datos JSON - se puede utilizar como una simple impresora bonita, o como una línea de comandos de Javascript de plena potencia
• POTENTE - Expone toda la potencia y la funcionalidad de underscore.js (más underscore.string)
• SIMPLE - Hace que sea fácil de escribir una sola línea JS similares a la utilización de "perl -pe"
• ENCADENADA - invokations comando múltiples se pueden encadenar juntos para crear una canalización de procesamiento de datos
• MULTI fORMATO - Rich soporte para formatos de entrada/salida - de impresión legible, el estricto JSON, etc [próximamente]
• DOCUMENTADA - documentación de línea de comandos excelente con múltiples ejemplos para cada comando

Se le 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 "Smart-espacios en blanco" formateadores JSON disponibles:

Si tiene alguna solicitudes de funciones, comentar esta publicación o agregar un problema en github. Estaría encantado de priorizar las características que necesitan los miembros de la comunidad.

Answer 7

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 hay que señalar que este será ordenar alfabéticamente todas las teclas, lo que es o puede ser una buena cosa en donde el JSON fue generada por un lenguaje que utiliza HashMaps desordenadas ...

Answer 8

acabo hizo jkid que es un pequeño json explorador de línea de comandos que hice para explorar fácilmente grandes objetos json. Los objetos pueden explorarse "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" 
} 

Answer 9

Si usted está buscando una herramienta portátil compilado en C:

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

Desde el sitio web:

JQ es como sed para los datos JSON - se puede Úselo para cortar, filtrar, mapear y transformar datos estructurados con la misma facilidad que sed, awk, grep y sus amigos le permiten jugar con el texto.

jq puede manipular el formato de datos que tiene 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/

Answer 10

Para Bash/Python, aquí es una envoltura básico en torno pitón de 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 del diccionario anidado, 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 desean obtener una fuente en otra dependencia externa. Excepto por Python, por supuesto.

Ej. json_parser {field1} {field2} se ejecutará print myjson['{field1}']['{field2}'], produciendo las claves o los valores asociados con {field2}, separados por espacios.