Unix-Befehlszeilen-JSON-Parser? [geschlossen]

Kann jemand einen Unix-JSON-Parser (wählen Sie Ihren Geschmack) empfehlen, mit dem Werte aus einer JSON-Antwort in einer Pipeline überprüft werden können?

Sie können diesen Befehlszeilenparser (den Sie bei Bedarf in einen Bash-Alias ​​einfügen können) verwenden, indem Sie Module verwenden, die in den Perl-Kern integriert sind:

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

Ich bevorzuge, python -m json.toolwelche standardmäßig auf den meisten * nix-Betriebssystemen standardmäßig verfügbar zu sein scheint.

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

Es sollte jedoch beachtet werden, dass dadurch alle Schlüssel alphabetisch sortiert werden. Dies ist oder kann eine gute Sache sein, wenn der JSON von einer Sprache generiert wurde, die ungeordnete HashMaps verwendet ...

Wenn Sie nach einem tragbaren C-kompilierten Tool suchen:

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

Von der Website:

jq ist wie sed für JSON-Daten - Sie können es verwenden, um strukturierte Daten mit der gleichen Leichtigkeit zu schneiden, zu filtern, zuzuordnen und zu transformieren, mit der sed , awk , grep und Freunde Sie mit Text spielen lassen.

jq kann das Datenformat, das Sie haben, mit sehr geringem Aufwand in das gewünschte Datenformat zerlegen, und das Programm dafür ist oft kürzer und einfacher als erwartet.

Tutorial : http://stedolan.github.com/jq/tutorial/
Handbuch : http://stedolan.github.com/jq/manual/
Download : http://stedolan.github.com/jq/download/

Ich habe ein Modul erstellt, das speziell für die Befehlszeilen-JSON-Manipulation entwickelt wurde:

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

• FLEXIBLE - DAS "Schweizer Taschenmesser " -Tool zur Verarbeitung von JSON-Daten - kann als einfacher hübscher Drucker oder als voll funktionsfähige Javascript-Befehlszeile verwendet werden
• POWERFUL - Zeigt die volle Leistung und Funktionalität von underscore.js (plus underscore.string) an.
• EINFACH - Erleichtert das Schreiben von JS-Einzeilern ähnlich der Verwendung von "perl -pe"
• CHAINED - Mehrere Befehlsaufrufe können miteinander verkettet werden, um eine Datenverarbeitungspipeline zu erstellen
• MULTI-FORMAT - Umfangreiche Unterstützung für Eingabe- / Ausgabeformate - hübsches Drucken, striktes JSON usw. [in Kürze]
• DOKUMENTIERT - Hervorragende Befehlszeilendokumentation mit mehreren Beispielen für jeden Befehl

Es ermöglicht Ihnen, mächtige Dinge wirklich einfach zu tun:

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

Und es hat einen der besten verfügbaren "Smart-Whitespace" -JSON-Formatierer:

Wenn Sie Funktionswünsche haben, kommentieren Sie diesen Beitrag oder fügen Sie ein Problem in github hinzu. Ich würde gerne Funktionen priorisieren, die von Mitgliedern der Community benötigt werden.

Kasse TickTick .

Es ist ein echter Bash JSON-Parser.

#!/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"]``

Es gibt auch ein JSON-Toolkit zur Befehlszeilenverarbeitung für die wenn Sie zufällig node.js und npm in Ihrem Stapel haben.

Und ein weiterer "json" -Befehl zum Massieren von JSON in Ihrer Unix-Befehlszeile.

Und hier sind die anderen Alternativen:

• jq: http://stedolan.github.io/jq/
• fx: https://github.com/antonmedv/fx
• json: Wählen Sie: https://github.com/dominictarr/json-select
• json-Befehl: 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

Verwandte: Befehlszeilentool zum Parsen von JSON-Eingaben für Unix?

Hat jemand Jshon oder JSON.sh erwähnt?

https://github.com/keenerd/jshon

Pipe Json dorthin, und es durchläuft die JSON-Objekte und druckt den Pfad zum aktuellen Objekt (als JSON-Array) und dann zum Objekt ohne Leerzeichen aus.

http://kmkeen.com/jshon/
Jshon lädt json-Text von stdin, führt Aktionen aus, zeigt dann die letzte Aktion auf stdout an und wurde als Teil der üblichen Textverarbeitungspipeline festgelegt.

Sie können jsawk wie in dieser Antwort vorgeschlagen ausprobieren .

Wirklich, Sie könnten ein schnelles Python-Skript erstellen, um dies zu tun.

Für Bash / Python gibt es hier einen grundlegenden Wrapper für Pythons 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 
}

Es behandelt wirklich nur den verschachtelten Wörterbuchstil von Daten, aber es funktioniert für das, was ich brauchte, und ist nützlich, um durch den JSON zu gehen. Es könnte wahrscheinlich nach Geschmack angepasst werden.

Wie auch immer, etwas Eigenes für diejenigen, die keine weitere externe Abhängigkeit herstellen möchten. Außer natürlich Python.

Ex. json_parser {field1} {field2}würde laufen print myjson['{field1}']['{field2}']und entweder die Schlüssel oder die damit verbundenen Werte durch {field2}Leerzeichen trennen.

Ich habe gerade jkid erstellt , einen kleinen Befehlszeilen- JSON -Explorer, den ich erstellt habe, um große JSON-Objekte einfach zu erkunden. Objekte können "quer" untersucht werden, und eine "Vorschau" -Option dient dazu, einen Konsolenüberlauf zu vermeiden.

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