Analyseur JSON en ligne de commande Unix? [fermé]

Quelqu'un peut-il recommander un analyseur JSON Unix (choisissez votre saveur) qui pourrait être utilisé pour introspecter les valeurs d'une réponse JSON dans un pipeline?

Vous pouvez utiliser cet analyseur de ligne de commande (que vous pouvez mettre dans un alias bash si vous le souhaitez), en utilisant des modules intégrés au cœur de Perl:

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

Je préfère python -m json.toolce qui semble être disponible par défaut sur la plupart des systèmes d'exploitation * nix par défaut.

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

Mais il convient de noter que cela triera toutes les clés par ordre alphabétique, ce qui est ou peut être une bonne chose lorsque le json a été généré par un langage utilisant des HashMaps non ordonnés ...

Si vous recherchez un outil compilé C portable:

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

Depuis le site Web:

jq est comme sed pour les données JSON - vous pouvez l'utiliser pour découper, filtrer, mapper et transformer des données structurées avec la même facilité que sed , awk , grep et friends vous permettent de jouer avec du texte.

jq peut modifier le format de données que vous avez dans celui que vous voulez avec très peu d'effort, et le programme pour le faire est souvent plus court et plus simple que prévu.

Tutoriel : http://stedolan.github.com/jq/tutorial/
Manuel : http://stedolan.github.com/jq/manual/
Téléchargement : http://stedolan.github.com/jq/download/

J'ai créé un module spécialement conçu pour la manipulation JSON en ligne de commande:

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

• FLEXIBLE - L'outil "couteau suisse" pour le traitement des données JSON - peut être utilisé comme une simple jolie imprimante, ou comme une ligne de commande Javascript pleine puissance
• PUISSANT - Expose toute la puissance et les fonctionnalités de underscore.js (plus underscore.string)
• SIMPLE - Simplifie l'écriture de one-liners JS similaire à l'utilisation de "perl -pe"
• CHAINED - Plusieurs invocations de commandes peuvent être enchaînées pour créer un pipeline de traitement de données
• MULTI-FORMAT - Prise en charge riche des formats d'entrée / sortie - jolie impression, JSON strict, etc. [bientôt disponible]
• DOCUMENTÉ - Excellente documentation en ligne de commande avec plusieurs exemples pour chaque commande

Cela vous permet de faire des choses puissantes très facilement:

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

Et il possède l'un des meilleurs formateurs JSON "smart-white" disponibles:

Si vous avez des demandes de fonctionnalités, commentez cet article ou ajoutez un problème dans github. Je serais heureux de donner la priorité aux fonctionnalités dont les membres de la communauté ont besoin.

Caisse TickTick .

C'est un véritable analyseur 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"]``

Il existe également une boîte à outils de traitement de ligne de commande JSON si vous avez node.js et npm dans votre pile.

Et une autre commande "json" pour masser JSON sur votre ligne de commande Unix.

Et voici les autres alternatives:

• jq: http://stedolan.github.io/jq/
• fx: https://github.com/antonmedv/fx
• json: sélectionnez: https://github.com/dominictarr/json-select
• json-commande: 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

Connexes: Outil de ligne de commande pour analyser l'entrée JSON pour Unix?

Quelqu'un a mentionné Jshon ou JSON.sh?

https://github.com/keenerd/jshon

pipe json vers lui, et il parcourt les objets json et imprime le chemin vers l'objet courant (sous forme de tableau JSON), puis l'objet, sans espace.

http://kmkeen.com/jshon/
Jshon charge du texte json à partir de stdin, effectue des actions, puis affiche la dernière action sur stdout et a également été conçu pour faire partie du pipeline de traitement de texte habituel.

Vous pouvez essayer jsawk comme suggéré dans cette réponse .

Vraiment, vous pouvez créer un script python rapide pour le faire.

Pour Bash / Python , voici un wrapper de base autour 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 
}

Il ne gère vraiment que le style de dictionnaire imbriqué des données, mais cela fonctionne pour ce dont j'avais besoin et est utile pour parcourir le json. Il pourrait probablement être adapté au goût.

Quoi qu'il en soit, quelque chose de propre pour ceux qui ne veulent pas se procurer une autre dépendance externe. Sauf pour python, bien sûr.

Ex. json_parser {field1} {field2}s'exécuterait print myjson['{field1}']['{field2}'], donnant soit les clés, soit les valeurs associées à {field2}, séparées par des espaces.

Je viens de créer jkid qui est un petit explorateur json en ligne de commande que j'ai créé pour explorer facilement de gros objets json. Les objets peuvent être explorés «transversalement» et une option «aperçu» est là pour éviter le débordement de la console.

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