Parser JSON wiersza poleceń systemu Unix? [Zamknięte]

Czy ktoś może polecić uniksowy parser JSON (wybierz swój smak), którego można by użyć do introspekcji wartości z odpowiedzi JSON w potoku?

Możesz użyć tego parsera wiersza poleceń (który możesz umieścić w aliasie bash, jeśli chcesz), używając modułów wbudowanych w rdzeń Perla:

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

Wolę, python -m json.toolktóry domyślnie wydaje się być dostępny w większości systemów operacyjnych * nix.

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

Uwaga: w zależności od wersji Pythona wszystkie klucze mogą być sortowane alfabetycznie, co może być dobre lub nie. W Pythonie 2 domyślnie sortowano klucze, podczas gdy w Pythonie 3.5+ nie są one już sortowane automatycznie, ale masz możliwość jawnego sortowania według klucza:

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

Jeśli szukasz przenośnego narzędzia skompilowanego w C:

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

Ze strony internetowej:

jq jest jak sed dla danych JSON - można go używać do wycinania, filtrowania, mapowania i przekształcania danych strukturalnych z taką samą łatwością, z jaką sed , awk , grep i przyjaciele pozwalają bawić się tekstem.

jq może zmienić format danych, który masz, na taki, który chcesz, przy niewielkim wysiłku, a program do tego jest często krótszy i prostszy niż można by się spodziewać.

Samouczek : http://stedolan.github.com/jq/tutorial/
Podręcznik : http://stedolan.github.com/jq/manual/
Pobierz : http://stedolan.github.com/jq/download/

Stworzyłem moduł specjalnie zaprojektowany do manipulacji JSON z linii poleceń:

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

• ELASTYCZNE - narzędzie „szwajcarskiego scyzoryka” do przetwarzania danych JSON - może być używane jako prosta ładna drukarka lub jako pełnowartościowy wiersz poleceń Javascript
• POTĘŻNY - Ujawnia pełną moc i funkcjonalność underscore.js (plus underscore.string)
• PROSTE - Ułatwia pisanie jednowierszowych w JS, podobnie jak przy użyciu „perl -pe”
• W ŁAŃCUCHU - wiele wywołań poleceń można połączyć w łańcuch, aby utworzyć potok przetwarzania danych
• MULTI-FORMAT - Bogate wsparcie dla formatów wejścia / wyjścia - ładne drukowanie, ścisły JSON itp. [Wkrótce]
• DOKUMENTOWANE - Doskonała dokumentacja wiersza poleceń z wieloma przykładami dla każdego polecenia

Pozwala naprawdę łatwo robić potężne rzeczy:

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

Ma też jeden z najlepszych dostępnych programów formatujących JSON „inteligentnych białych znaków”:

Jeśli masz jakieś prośby o dodanie funkcji, skomentuj ten post lub dodaj problem na githubie. Chętnie nadam priorytet funkcjom, które są potrzebne członkom społeczności.

Checkout TickTick .

To prawdziwy 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"]``

Istnieje również zestaw narzędzi do przetwarzania wiersza poleceń JSON, jeśli masz na stosie node.js i npm.

I jeszcze jedno polecenie "json" do masowania JSON w linii poleceń Uniksa.

A oto inne alternatywy:

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

Powiązane: Narzędzie wiersza poleceń do analizowania danych wejściowych JSON dla systemu Unix?

Czy ktoś wspomniał o Jshon lub JSON.sh?

https://github.com/keenerd/jshon

potokiem json do niego i przechodzi przez obiekty json i wyświetla ścieżkę do bieżącego obiektu (jako tablica JSON), a następnie obiekt, bez spacji.

http://kmkeen.com/jshon/
Jshon ładuje tekst json ze stdin, wykonuje akcje, a następnie wyświetla ostatnią akcję na stdout, a także został utworzony jako część zwykłego potoku przetwarzania tekstu.

Możesz spróbować jsawk zgodnie z sugestią zawartą w tej odpowiedzi .

Naprawdę możesz jednak stworzyć szybki skrypt w Pythonie, aby to zrobić.

W przypadku Bash / Python , oto podstawowe opakowanie wokół Pythona 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 
}

Naprawdę obsługuje tylko dane w stylu zagnieżdżonego słownika, ale działa zgodnie z potrzebami i jest przydatne do przechodzenia przez json. Prawdopodobnie dałoby się to dostosować do smaku.

W każdym razie coś wyhodowanego w domu dla tych, którzy nie chcą czerpać z jeszcze jednej zewnętrznej zależności. Oczywiście z wyjątkiem Pythona.

Dawny. json_parser {field1} {field2}uruchomi się print myjson['{field1}']['{field2}'], uzyskując klucze lub powiązane z nimi wartości {field2}, oddzielone spacjami.

Właśnie stworzyłem jkid, który jest małym eksploratorem json wiersza poleceń, który stworzyłem, aby łatwo eksplorować duże obiekty json. Obiekty można eksplorować „poprzecznie”, a opcja „podgląd” pozwala uniknąć przepełnienia konsoli.

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