Existe-t-il un script shell (Unix) pour formater JSON sous une forme lisible par l'homme?

Fondamentalement, je veux qu'il transforme les éléments suivants:

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

... en quelque chose comme ça:

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

Avec Python 2.6+, vous pouvez simplement faire:

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

ou, si le JSON est dans un fichier, vous pouvez faire:

python -m json.tool my_json.json

si le JSON provient d'une source Internet telle qu'une API, vous pouvez utiliser

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

Pour plus de commodité dans tous ces cas, vous pouvez créer un alias:

alias prettyjson='python -m json.tool'

Pour encore plus de commodité avec un peu plus de frappe pour le préparer:

prettyjson_s() {
    echo "$1" | python -m json.tool
}

prettyjson_f() {
    python -m json.tool "$1"
}

prettyjson_w() {
    curl "$1" | python -m json.tool
}

pour tous les cas ci-dessus. Vous pouvez le mettre .bashrcet il sera disponible à chaque fois dans le shell. Invoquez-le comme prettyjson_s '{"foo": "lorem", "bar": "ipsum"}'.

Vous pouvez utiliser: jq

C'est très simple à utiliser et ça marche très bien! Il peut gérer de très grandes structures JSON, y compris des flux. Vous pouvez trouver leurs tutoriels ici .

Exemples d'utilisation:

$ 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"
}

Le . est le filtre d'identité.

J'utilise l'argument "espace" de JSON.stringifypour imprimer assez JSON en JavaScript.

Exemples:

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

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

Depuis la ligne de commande Unix avec Node.js, en spécifiant JSON sur la ligne de commande:

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

Retour:

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

Depuis la ligne de commande Unix avec Node.js, en spécifiant un nom de fichier qui contient JSON et en utilisant un retrait de quatre espaces:

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

Utilisation d'un tuyau:

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

J'ai écrit un outil qui possède l'un des meilleurs formateurs "d'espaces blancs intelligents" disponibles. Il produit une sortie plus lisible et moins détaillée que la plupart des autres options ici.

underscore-cli

Voici à quoi ressemble un "espace blanc intelligent":

Je suis peut-être un peu biaisé, mais c'est un outil génial pour imprimer et manipuler des données JSON à partir de la ligne de commande. Il est très convivial à utiliser et dispose d'une aide / documentation en ligne de commande étendue. C'est un couteau suisse que j'utilise pour 1001 petites tâches différentes qui seraient étonnamment ennuyeuses à faire autrement.

Dernier cas d'utilisation: Chrome, console de développement, onglet Réseau, tout exporter sous forme de fichier HAR, "cat site.har | underscore select '.url' --outfmt text | grep mydomain"; J'ai maintenant une liste chronologiquement ordonnée de toutes les récupérations d'URL effectuées pendant le chargement du site de mon entreprise.

La jolie impression est facile:

underscore -i data.json print

Même chose:

cat data.json | underscore print

Même chose, plus explicite:

cat data.json | underscore print --outfmt pretty

Cet outil est mon projet de passion actuel, donc si vous avez des demandes de fonctionnalités, il y a de fortes chances que je les adresse.

Je fais habituellement juste:

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

Et pour récupérer des données sélectionnées (dans ce cas, la valeur de "test"):

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

Si les données JSON sont dans un fichier:

python -mjson.tool filename.json

Si vous voulez tout faire en une seule fois avec curlsur la ligne de commande en utilisant un jeton d'authentification:

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

Grâce aux pointeurs très utiles de JF Sebastian, voici un script légèrement amélioré que j'ai trouvé:

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

Si vous utilisez npm et Node.js, vous pouvez le faire npm install -g json, puis diriger la commande json. Faites json -hpour obtenir toutes les options. Il peut également extraire des champs spécifiques et coloriser la sortie avec -i.

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

Ce n'est pas trop simple avec une manière native avec les outils jq .

Par exemple:

cat xxx | jq .

Avec Perl, utilisez le module CPAN JSON::XS. Il installe un outil en ligne de commande json_xs.

Valider:

json_xs -t null < myfile.json

Prettifiez le fichier JSON src.jsonpour pretty.json:

< src.json json_xs > pretty.json

Si ce n'est pas le cas json_xs, essayez json_pp. "pp" est pour "pure perl" - l'outil est implémenté en Perl uniquement, sans liaison à une bibliothèque C externe (ce que XS signifie, "Extension System" de Perl).

Sur * nix, la lecture depuis stdin et l'écriture vers stdout fonctionnent mieux:

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

Mettez ceci dans un fichier (j'ai nommé le mien "prettyJSON" d'après la réponse d' AnC ) dans votre PATH et chmod +xça, et vous êtes prêt à partir.

Le JSON Ruby Gem est fourni avec un script shell pour embellir JSON:

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

Téléchargement du script: gist.github.com/3738968

MISE À JOUR J'utilise jqmaintenant comme suggéré dans une autre réponse. Il est extrêmement puissant pour filtrer le JSON, mais, dans sa forme la plus basique, c'est aussi un excellent moyen d'imprimer JSON pour le visualiser.

jsonpp est une très jolie imprimante JSON en ligne de commande.

Du README:

Jolies réponses de service Web imprimées comme ceci:

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

et embellissez les fichiers qui circulent sur votre disque:

jsonpp data/long_malformed.json

Si vous êtes sous Mac OS X, vous le pouvez brew install jsonpp. Sinon, vous pouvez simplement copier le binaire quelque part dans votre fichier $PATH.

Voilà comment je le fais:

curl yourUri | json_pp

Il raccourcit le code et fait le travail.

un simple script bash pour une jolie impression 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}'

Exemple:

cat file.json | json_pretty.sh

Essayez pjson. Il a des couleurs!

Installez-le avec pip:

⚡ pip install pjson

Et dirigez ensuite tout contenu JSON vers 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"
}

REMARQUE: ce n'est pas la façon de procéder.

La même chose en Perl:

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

Remarque 2: si vous exécutez

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

le mot bien lisible devient \ u encodé

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

Si le reste de votre pipeline gèrera correctement unicode et que vous souhaitez que votre JSON soit également convivial, utilisez simplement 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)'

et vous obtiendrez:

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

J'utilise jshon pour faire exactement ce que vous décrivez. Exécutez simplement:

echo $COMPACTED_JSON_TEXT | jshon

Vous pouvez également transmettre des arguments pour transformer les données JSON.

Ou, avec Ruby:

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

Découvrez Jazor . Il s'agit d'un simple analyseur JSON en ligne de commande écrit en Ruby.

gem install jazor
jazor --help

Vous pouvez utiliser cette commande simple pour obtenir le résultat:

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

JSONLint a une implémentation open-source sur GitHub qui peut être utilisée sur la ligne de commande ou incluse dans un projet Node.js.

npm install jsonlint -g

et alors

jsonlint -p myfile.json

ou

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

Dirigez simplement la sortie vers jq ..

Exemple:

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

Avec Perl, si vous installez JSON :: PP à partir de CPAN, vous obtiendrez la commande json_pp . En volant l' exemple de B Bycroft, vous obtenez:

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

Il convient de mentionner qu'il json_ppest préinstallé avec Ubuntu 12.04 (au moins) et Debian dans/usr/bin/json_pp

Pygmentize

Je combine json.tool de Python avec pygmentize:

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

Il existe quelques alternatives à pygmentize qui sont répertoriées dans ma cette réponse .

Voici une démo en direct:

Je recommande d'utiliser l'utilitaire de ligne de commande json_xs qui est inclus dans le module perl JSON :: XS. JSON :: XS est un module Perl pour sérialiser / désérialiser JSON, sur une machine Debian ou Ubuntu vous pouvez l'installer comme ceci:

sudo apt-get install libjson-xs-perl

Il est évidemment également disponible sur CPAN .

Pour l'utiliser pour formater le JSON obtenu à partir d'une URL, vous pouvez utiliser curl ou wget comme ceci:

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

ou ca:

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

et pour formater le JSON contenu dans un fichier, vous pouvez le faire:

$ json_xs < file-full-of.json

Pour reformater en YAML , que certaines personnes considèrent comme plus lisible humainement que JSON:

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

Vous pouvez simplement utiliser des outils standard comme jq ou json_pp.

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

ou

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

va à la fois embellir la sortie comme suit (jq encore plus coloré):

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

L'énorme avantage de jq est qu'il peut faire beaucoup plus si vous souhaitez analyser et traiter le json.

jj est super rapide, peut gérer des documents JSON gigantesques de manière économique, ne dérange pas avec les numéros JSON valides et est facile à utiliser, par exemple

jj -p # for reading from STDIN

ou

jj -p -i input.json

C'est (2018) encore assez nouveau, donc il ne traitera peut-être pas le JSON invalide comme vous l'attendez, mais il est facile à installer sur les principales plates-formes.

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

batest un catclone avec une coloration syntaxique:

Exemple:

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

-paffichera sans en-têtes et -lspécifiera explicitement la langue.

Il a la coloration et le formatage pour JSON et n'a pas les problèmes notés dans ce commentaire: Comment puis-je joli-imprimer JSON dans un script shell?

Installez yajl-tools avec la commande ci-dessous:

sudo apt-get install yajl-tools

puis,

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