Analisador JSON de linha de comando Unix? [fechadas]

Alguém pode recomendar um analisador JSON do Unix (escolha seu sabor) que possa ser usado para examinar valores de uma resposta JSON em um pipeline?

Você pode usar esse analisador de linha de comando (que você pode colocar em um alias do bash, se quiser), usando módulos integrados no núcleo do Perl:

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

Prefiro o python -m json.toolque parece estar disponível por padrão na maioria dos sistemas operacionais * nix por padrão.

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

Mas deve-se notar que isso ordenará todas as chaves em ordem alfabética, o que é ou pode ser uma coisa boa em que o json foi gerado por algum idioma que usou HashMaps não-ordenados ...

Se você está procurando uma ferramenta compilada C portátil:

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

A partir do site:

O jq é como sed para dados JSON - você pode usá-lo para cortar, filtrar, mapear e transformar dados estruturados com a mesma facilidade que sed , awk , grep e amigos permitem que você jogue com texto.

O jq pode alterar o formato de dados que você possui para o formato desejado com muito pouco esforço, e o programa para isso é geralmente mais curto e mais simples do que o esperado.

Tutorial : http://stedolan.github.com/jq/tutorial/
Manual : http://stedolan.github.com/jq/manual/
Faça o download : http://stedolan.github.com/jq/download/

Eu criei um módulo projetado especificamente para manipulação JSON da linha de comando:

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

• FLEXÍVEL - A ferramenta "swiss-army-knife" para processamento de dados JSON - pode ser usada como uma simples impressora bonita ou como uma linha de comando Javascript com potência total
• PODEROSO - Expõe todo o poder e funcionalidade do underscore.js (mais underscore.string)
• SIMPLES - Simplifica a criação de linhas de código JS semelhantes ao uso de "perl -pe"
• CHAINED - Várias chamadas de comando podem ser encadeadas para criar um pipeline de processamento de dados
• MULTI-FORMAT - Suporte avançado para formatos de entrada / saída - impressão bonita, JSON estrito, etc. [em breve]
• DOCUMENTADO - Excelente documentação de linha de comando com vários exemplos para cada comando

Ele permite que você faça coisas poderosas com muita facilidade:

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

E possui um dos melhores formatadores JSON de "espaço em branco inteligente" disponíveis:

Se você tiver alguma solicitação de recurso, comente esta postagem ou adicione um problema no github. Ficaria feliz em priorizar os recursos necessários aos membros da comunidade.

TickTick do checkout .

É um verdadeiro analisador 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"]``

Há também kit de ferramentas de processamento de linha de comando JSON se você tiver node.js e npm em sua pilha.

E outro comando "json" para massagear JSON na sua linha de comando do Unix.

E aqui estão as outras alternativas:

• jq: http://stedolan.github.io/jq/
• fx: https://github.com/antonmedv/fx
• json: selecione: https://github.com/dominictarr/json-select
• json-command: 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: Ferramenta de linha de comando para analisar a entrada JSON do Unix?

Alguém mencionou Jshon ou JSON.sh?

https://github.com/keenerd/jshon

canalize o json para ele e ele percorre os objetos json e imprime o caminho para o objeto atual (como uma matriz JSON) e depois o objeto, sem espaço em branco.

http://kmkeen.com/jshon/ O
Jshon carrega o texto json do stdin, executa ações, exibe a última ação no stdout e também foi criado para fazer parte do pipeline de processamento de texto usual.

Você pode tentar o jsawk, conforme sugerido nesta resposta .

Na verdade, você pode criar um script python rápido para fazer isso.

Para Bash / Python , aqui está um wrapper básico em torno do 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 
}

Ele realmente lida apenas com o estilo de dados do dicionário aninhado, mas funciona para o que eu precisava e é útil para percorrer o json. Provavelmente poderia ser adaptado ao gosto.

Enfim, algo caseiro para aqueles que não desejam obter mais uma dependência externa. Exceto por python, é claro.

Ex. json_parser {field1} {field2}seria executado print myjson['{field1}']['{field2}'], produzindo as chaves ou os valores associados a {field2}, separados por espaço.

Acabei de criar o jkid, que é um pequeno json explorer de linha de comando que fiz para explorar facilmente objetos grandes do json. Os objetos podem ser explorados "transversalmente" e existe uma opção de "visualização" para evitar o estouro do console.

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