Existe um shell script (Unix) para formatar JSON em formato legível por humanos?

Basicamente, quero transformar o seguinte:

{ "foo": "lorem", "bar": "ipsum" }

... em algo assim:

{
    "foo": "lorem",
    "bar": "ipsum"
}

Com o Python 2.6+, você pode fazer:

echo '{"foo": "lorem", "bar": "ipsum"}' | python -m json.tool

ou, se o JSON estiver em um arquivo, você poderá:

python -m json.tool my_json.json

se o JSON for de uma fonte da Internet como uma API, você poderá usar

curl http://my_url/ | python -m json.tool

Por conveniência, em todos esses casos, você pode criar um alias:

alias prettyjson='python -m json.tool'

Para uma conveniência ainda maior, com um pouco mais de digitação para prepará-lo:

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 os casos acima. Você pode colocar isso .bashrce ele estará disponível todas as vezes no shell. Invoque-o como prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'.

Você pode usar: jq

É muito simples de usar e funciona muito bem! Ele pode lidar com estruturas JSON muito grandes, incluindo fluxos. Você pode encontrar os tutoriais aqui .

Exemplos de uso:

$ jq --color-output . file1.json file1.json | less -R

$ command_with_json_output | jq .

$ jq . # stdin/"interactive" mode, just enter some JSON

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

O . é o filtro de identidade.

Eu uso o argumento "space" JSON.stringifypara imprimir JSON em JavaScript.

Exemplos:

// Indent with 4 spaces
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, 4);

// Indent with tabs
JSON.stringify({"foo":"lorem","bar":"ipsum"}, null, '\t');

Na linha de comando do Unix com Node.js, especificando JSON na linha de comandos:

$ node -e "console.log(JSON.stringify(JSON.parse(process.argv[1]), null, '\t'));" \
  '{"foo":"lorem","bar":"ipsum"}'

Devoluções:

{
    "foo": "lorem",
    "bar": "ipsum"
}

Na linha de comando do Unix com Node.js, especificando um nome de arquivo que contém JSON e usando um recuo de quatro espaços:

$ node -e "console.log(JSON.stringify(JSON.parse(require('fs') \
      .readFileSync(process.argv[1])), null, 4));"  filename.json

Usando um cano:

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));\
 });\
"

Eu escrevi uma ferramenta que possui um dos melhores formatadores de "espaço em branco inteligente" disponíveis. Produz saída mais legível e menos detalhada do que a maioria das outras opções aqui.

sublinhado-cli

É assim que "espaço em branco inteligente" se parece:

Eu posso ser um pouco tendencioso, mas é uma ferramenta incrível para imprimir e manipular dados JSON a partir da linha de comando. É super amigável de usar e possui extensa ajuda / documentação de linha de comando. É um canivete suíço que eu uso para 1001 pequenas tarefas diferentes que seria surpreendentemente irritante de qualquer outra maneira.

Caso de uso mais recente: Chrome, console do desenvolvedor, guia Rede, exporte tudo como arquivo HAR ", cat site.har | sublinhado, selecione '.url' --outfmt text | grep mydomain"; agora eu tenho uma lista cronologicamente ordenada de todas as buscas de URL feitas durante o carregamento do site da minha empresa.

Impressão bonita é fácil:

underscore -i data.json print

Mesma coisa:

cat data.json | underscore print

A mesma coisa, mais explícita:

cat data.json | underscore print --outfmt pretty

Essa ferramenta é o meu projeto atual de paixão; portanto, se você tiver algum pedido de recurso, há uma boa chance de que eu os resolva.

Eu costumo fazer:

echo '{"test":1,"test2":2}' | python -mjson.tool

E para recuperar dados selecionados (neste caso, o valor de "teste"):

echo '{"test":1,"test2":2}' | python -c 'import sys,json;data=json.loads(sys.stdin.read()); print data["test"]'

Se os dados JSON estiverem em um arquivo:

python -mjson.tool filename.json

Se você quiser fazer tudo de uma só vez, curluse a linha de comando usando um token de autenticação:

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

Graças às dicas muito úteis de JF Sebastian, aqui está um script um pouco aprimorado que eu criei:

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

Se você usar o npm e o Node.js, poderá executar e npm install -g jsoncanalizar o comando json. Faça json -hpara obter todas as opções. Também pode extrair campos específicos e colorir a saída com -i.

curl -s http://search.twitter.com/search.json?q=node.js | json

Não é muito simples com uma maneira nativa com as ferramentas jq .

Por exemplo:

cat xxx | jq .

Com Perl, use o módulo CPAN JSON::XS. Ele instala uma ferramenta de linha de comando json_xs.

Validar:

json_xs -t null < myfile.json

Pretifique o arquivo JSON src.jsonpara pretty.json:

< src.json json_xs > pretty.json

Se você não tiver json_xs, tente json_pp. "pp" é para "perl puro" - a ferramenta é implementada apenas no Perl, sem uma ligação a uma biblioteca C externa (que é o que o XS representa, o "Sistema de Extensão" do Perl).

No * nix, ler de stdin e escrever para stdout funciona melhor:

#!/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)

Coloque isso em um arquivo (eu chamei meu de "prettyJSON" após a resposta do AnC ) em seu PATH chmod +x, e você estará pronto .

O JSON Ruby Gem é fornecido com um script de shell para pretender o JSON:

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

Download do script: gist.github.com/3738968

ATUALIZAÇÃO Estou usando jqagora, conforme sugerido em outra resposta. É extremamente poderoso na filtragem de JSON, mas, na sua forma mais básica, também é uma maneira incrível de imprimir bastante JSON para visualização.

O jsonpp é uma impressora bonita de JSON para linha de comando.

No README:

Respostas de serviços da Web de impressão bonitas, assim:

curl -s -L http://<!---->t.co/tYTq5Pu | jsonpp

e embeleze os arquivos que circulam no seu disco:

jsonpp data/long_malformed.json

Se você estiver no Mac OS X, poderá brew install jsonpp. Caso contrário, você pode simplesmente copiar o binário para algum lugar no seu $PATH.

É assim que eu faço:

curl yourUri | json_pp

Reduz o código e realiza o trabalho.

um script bash simples para uma bonita impressão json

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

Exemplo:

cat file.json | json_pretty.sh

Tente pjson. Tem cores!

Instale-o com pip:

⚡ pip install pjson

E então canalize qualquer conteúdo JSON para pjson.

$ 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: Não é o caminho para fazê-lo.

O mesmo em Perl:

$ cat json.txt \
> | perl -0007 -MJSON -nE'say to_json(from_json($_, {allow_nonref=>1}), 
>                                     {pretty=>1})'
{
   "bar" : "ipsum",
   "foo" : "lorem"
}

Nota 2: se você executar

echo '{ "Düsseldorf": "lorem", "bar": "ipsum" }' \
| python -c'import fileinput, json;
print(json.dumps(json.loads("".join(fileinput.input())),
                 sort_keys=True, indent=4))'

a palavra bem legível se torna \ u codificada

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

Se o restante do seu pipeline manipular graciosamente o unicode e você desejar que seu JSON também seja amigável ao ser humano, basta usar ensure_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)'

e você terá:

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

Eu uso o jshon para fazer exatamente o que você está descrevendo. Apenas corra:

echo $COMPACTED_JSON_TEXT | jshon

Você também pode transmitir argumentos para transformar os dados JSON.

Ou, com Ruby:

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

Confira Jazor . É um analisador JSON de linha de comando simples, escrito em Ruby.

gem install jazor
jazor --help

Você pode usar este comando simples para alcançar o resultado:

echo "{ \"foo\": \"lorem\", \"bar\": \"ipsum\" }"|python -m json.tool

O JSONLint possui uma implementação de código aberto no GitHub que pode ser usada na linha de comando ou incluída em um projeto Node.js.

npm install jsonlint -g

e depois

jsonlint -p myfile.json

ou

curl -s "http://api.twitter.com/1/users/show/user.json" | jsonlint | less

Basta canalizar a saída para jq . .

Exemplo:

twurl -H ads-api.twitter.com '.......' | jq .

Pycementize

Combino o json.tool do Python com pycementize:

echo '{"foo": "bar"}' | python -m json.tool | pygmentize -g

Existem algumas alternativas para pitonizar, listadas em minha resposta .

Aqui está uma demonstração ao vivo:

Com o Perl, se você instalar o JSON :: PP a partir do CPAN, receberá o comando json_pp . Roubando o exemplo de B Bycroft, você obtém:

[pdurbin@beamish ~]$ echo '{"foo": "lorem", "bar": "ipsum"}' | json_pp
{
   "bar" : "ipsum",
   "foo" : "lorem"
}

Vale ressaltar que json_ppvem pré-instalado com o Ubuntu 12.04 (pelo menos) e o Debian no/usr/bin/json_pp

Eu recomendo usar o utilitário de linha de comando json_xs, incluído no módulo JSON :: XS perl. JSON :: XS é um módulo Perl para serializar / desserializar JSON, em uma máquina Debian ou Ubuntu você pode instalá-lo assim:

sudo apt-get install libjson-xs-perl

Obviamente, também está disponível no CPAN .

Para usá-lo para formatar JSON obtido de uma URL, você pode usar curl ou wget assim:

$ curl -s http://page.that.serves.json.com/json/ | json_xs

ou isto:

$ wget -q -O - http://page.that.serves.json.com/json/ | json_xs

e para formatar o JSON contido em um arquivo, você pode fazer isso:

$ json_xs < file-full-of.json

Para reformatar como YAML , que algumas pessoas consideram mais legível por humanos do que JSON:

$ json_xs -t yaml < file-full-of.json

Você pode simplesmente usar ferramentas padrão como jq ou json_pp.

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

ou

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

ambos pretendem modificar a saída da seguinte forma (jq ainda mais colorido):

{
  "foo": "lorem",
  "bar": "ipsum"
}

A grande vantagem do jq é que ele pode fazer muito mais se você quiser analisar e processar o json.

jj é super rápido, pode lidar com documentos JSON ginormous economicamente, não mexe com números JSON válidos e é fácil de usar, por exemplo

jj -p # for reading from STDIN

ou

jj -p -i input.json

É (2018) ainda bastante novo, então talvez não lide com JSON inválido da maneira que você espera, mas é fácil de instalar nas principais plataformas.

1. brew install jq
2. command + | jq
3. (exemplo: curl localhost:5000/blocks | jq :)
4. Aproveitar!

bat é um cat clone com destaque de sintaxe:

Exemplo:

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

-pproduzirá sem cabeçalhos e -lespecificará explicitamente o idioma.

Possui coloração e formatação para JSON e não apresenta os problemas mencionados neste comentário: Como posso imprimir JSON em um script de shell?

Instale o yajl-tools com o comando abaixo:

sudo apt-get install yajl-tools

então,

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