Parser JSON da riga di comando Unix? [chiuso]

Qualcuno può raccomandare un parser JSON Unix (scegli il tuo sapore) che potrebbe essere usato per introspettare i valori da una risposta JSON in una pipeline?

Puoi usare questo parser da riga di comando (che potresti mettere in un alias bash se vuoi), usando i moduli integrati nel core Perl:

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

Preferisco python -m json.toolche sembra essere disponibile per impostazione predefinita sulla maggior parte dei sistemi operativi * nix per impostazione predefinita.

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

Ma va notato che questo ordinerà tutti i tasti in ordine alfabetico, che è o può essere una buona cosa in cui il json è stato generato da un linguaggio che utilizzava HashMaps non ordinate ...

Se stai cercando uno strumento compilato C portatile:

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

Dal sito Web:

jq è come sed per i dati JSON: puoi usarlo per suddividere, filtrare, mappare e trasformare i dati strutturati con la stessa facilità con cui sed , awk , grep e friends ti permettono di giocare con il testo.

jq può manipolare il formato dei dati che hai in quello che desideri con il minimo sforzo e il programma per farlo è spesso più breve e più semplice di quanto ti aspetteresti.

Tutorial : http://stedolan.github.com/jq/tutorial/
Manuale : http://stedolan.github.com/jq/manual/
Scarica : http://stedolan.github.com/jq/download/

Ho creato un modulo appositamente progettato per la manipolazione della riga di comando JSON:

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

• FLESSIBILE - LO strumento "coltellino svizzero" per l'elaborazione di dati JSON - può essere usato come una semplice stampante o come una riga di comando Javascript a piena potenza
• POTENTE - Espone tutta la potenza e la funzionalità di underscore.js (più underscore.string)
• SEMPLICE : semplifica la scrittura di una riga di JS simile all'utilizzo di "perl -pe"
• CATENA : più invocazioni di comandi possono essere concatenate per creare una pipeline di elaborazione dati
• MULTI-FORMATO - Ricco supporto per formati di input / output - bella stampa, JSON rigoroso, ecc. [Presto disponibile]
• DOCUMENTATO - Eccellente documentazione da riga di comando con più esempi per ogni comando

Ti permette di fare cose potenti davvero facilmente:

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 ha uno dei migliori formattatori JSON "smart-whitespace" disponibili:

Se hai richieste di funzionalità, commenta questo post o aggiungi un problema in github. Sarei felice di dare la priorità alle funzionalità che sono necessarie ai membri della community.

Checkout TickTick .

È un vero parser 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"]``

Esiste anche un toolkit di elaborazione della riga di comando JSON se nel tuo stack sono presenti node.js e npm.

E un altro comando "json" per massaggiare JSON sulla tua riga di comando Unix.

Ed ecco le altre alternative:

• jq: http://stedolan.github.io/jq/
• fx: https://github.com/antonmedv/fx
• json: selezionare: 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

Correlati: strumento da riga di comando per l'analisi dell'input JSON per Unix?

Qualcuno ha menzionato Jshon o JSON.sh?

https://github.com/keenerd/jshon

pipe json e attraversa gli oggetti json e stampa il percorso dell'oggetto corrente (come un array JSON) e quindi l'oggetto, senza spazi bianchi.

http://kmkeen.com/jshon/
Jshon carica il testo json da stdin, esegue le azioni, quindi visualizza l'ultima azione su stdout ed è stato anche fatto parte della normale pipeline di elaborazione del testo.

Puoi provare jsawk come suggerito in questa risposta .

In realtà, però, potresti creare uno script Python per farlo.

Per Bash / Python , ecco un wrapper di base attorno a 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 
}

Gestisce davvero solo lo stile dei dati del dizionario nidificato, ma funziona per ciò di cui avevo bisogno ed è utile per camminare attraverso il json. Probabilmente potrebbe essere adattato a piacere.

Comunque, qualcosa di fatto in casa per coloro che non vogliono procurarsi un'altra ennesima dipendenza esterna. Tranne il pitone, ovviamente.

Ex. json_parser {field1} {field2}verrebbe eseguito print myjson['{field1}']['{field2}'], restituendo le chiavi o i valori associati {field2}, separati da spazi.

Ho appena creato jkid che è un piccolo esploratore json da riga di comando che ho creato per esplorare facilmente grandi oggetti json. Gli oggetti possono essere esplorati "trasversalmente" e un'opzione di "anteprima" è lì per evitare l'overflow della console.

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