Analiza JSON za pomocą narzędzi uniksowych

Próbuję przeanalizować JSON zwrócony z żądania curl, tak:

curl 'http://twitter.com/users/username.json' |
    sed -e 's/[{}]/''/g' | 
    awk -v k="text" '{n=split($0,a,","); for (i=1; i<=n; i++) print a[i]}'

Powyższe dzieli JSON na pola, na przykład:

% ...
"geo_enabled":false
"friends_count":245
"profile_text_color":"000000"
"status":"in_reply_to_screen_name":null
"source":"web"
"truncated":false
"text":"My status"
"favorited":false
% ...

Jak wydrukować określone pole (oznaczone przez -v k=text)?

Istnieje wiele narzędzi zaprojektowanych specjalnie do manipulowania JSON z poziomu wiersza poleceń i będzie o wiele łatwiejsze i bardziej niezawodne niż robienie tego z Awk, takie jak jq:

curl -s 'https://api.github.com/users/lambda' | jq -r '.name'

Można to również zrobić za pomocą narzędzi, które prawdopodobnie są już zainstalowane w systemie, takich jak Python korzystający z jsonmodułu , dzięki czemu można uniknąć dodatkowych zależności, a jednocześnie korzystać z właściwego parsera JSON. Poniżej założono, że chcesz użyć UTF-8, w którym powinien być zakodowany oryginalny JSON i jest to również to, czego używają najbardziej nowoczesne terminale:

Python 3:

curl -s 'https://api.github.com/users/lambda' | \
    python3 -c "import sys, json; print(json.load(sys.stdin)['name'])"

Python 2:

export PYTHONIOENCODING=utf8
curl -s 'https://api.github.com/users/lambda' | \
    python2 -c "import sys, json; print json.load(sys.stdin)['name']"

Notatki historyczne

Ta odpowiedź początkowo zalecała jsawk , który powinien nadal działać, ale jest nieco bardziej kłopotliwy w użyciu niż jqi zależy od zainstalowanego samodzielnego interpretera JavaScript, który jest mniej powszechny niż interpreter Pythona, więc powyższe odpowiedzi są prawdopodobnie preferowane:

curl -s 'https://api.github.com/users/lambda' | jsawk -a 'return this.name'

Ta odpowiedź również pierwotnie używała interfejsu API Twittera z pytania, ale ten interfejs API już nie działa, co utrudnia skopiowanie przykładów do przetestowania, a nowy interfejs API Twittera wymaga kluczy API, więc przełączyłem się na używanie interfejsu API GitHub, który może być łatwo używany bez kluczy API. Pierwsza odpowiedź na pierwotne pytanie brzmiałaby:

curl 'http://twitter.com/users/username.json' | jq -r '.text'

Aby szybko wyodrębnić wartości dla konkretnego klucza, osobiście lubię używać „grep -o”, który zwraca tylko dopasowanie wyrażenia regularnego. Na przykład, aby uzyskać pole „tekstowe” z tweetów, coś takiego:

grep -Po '"text":.*?[^\\]",' tweets.json

Ten wyrażenie regularne jest bardziej niezawodne, niż mogłoby się wydawać; na przykład dobrze radzi sobie z ciągami znaków z osadzonymi przecinkami i znakami cudzysłowu. Myślę, że przy odrobinie pracy można stworzyć taki, który w rzeczywistości gwarantuje wydobycie wartości, jeśli jest ona atomowa. (Jeśli ma zagnieżdżenie, wyrażenie regularne nie może tego oczywiście zrobić).

I do dalszego czysty (choć zachowując oryginalny ucieczce struny) można użyć coś takiego: | perl -pe 's/"text"://; s/^"//; s/",$//'. (Zrobiłem to dla tej analizy .)

Wszystkim hejterom, którzy nalegają, powinieneś użyć prawdziwego parsera JSON - tak, jest to niezbędne dla poprawności, ale

1. Aby dokonać naprawdę szybkiej analizy, na przykład zliczania wartości w celu sprawdzenia błędów czyszczenia danych lub uzyskania ogólnego wyczucia danych, wybijanie czegoś w wierszu poleceń jest szybsze. Otwieranie edytora w celu napisania skryptu jest rozpraszające.
2. grep -ojest o rząd wielkości szybszy niż standardowa jsonbiblioteka Pythona , przynajmniej w przypadku tweetów ( o wielkości ~ 2 KB każda). Nie jestem pewien, czy jsondzieje się tak tylko dlatego, że jest powolny (powinienem kiedyś porównać do yajla); ale w zasadzie wyrażenie regularne powinno być szybsze, ponieważ jest w stanie skończonym i jest o wiele bardziej możliwe do zoptymalizowania, zamiast parsera, który musi obsługiwać rekurencję, iw tym przypadku spędza wiele drzew budujących procesor dla struktur, na których ci nie zależy. (Gdyby ktoś napisał skończony przetwornik stanu, który poprawnie parsował JSON (z ograniczoną głębokością), byłoby fantastycznie! W międzyczasie mamy „grep -o”.)

Aby pisać możliwy do utrzymania kod, zawsze używam prawdziwej biblioteki parsującej. Nie próbowałem jsawk , ale jeśli działa dobrze, to adresowałby punkt 1.

Ostatnie, zwięzłe rozwiązanie: napisałem skrypt, który używa Pythona jsoni wyodrębnia klucze, które chcesz, do kolumn oddzielonych tabulatorami; następnie przepuszczam rurkę przez opakowanie, awkktóre umożliwia nazwany dostęp do kolumn. Tutaj: skrypty json2tsv i tsvawk . W tym przykładzie byłoby to:

json2tsv id text < tweets.json | tsvawk '{print "tweet " $id " is: " $text}'

Podejście to nie odnosi się do nr 2, jest bardziej nieefektywne niż pojedynczy skrypt Pythona i jest trochę kruche: wymusza normalizację znaków nowej linii i tabulatorów w wartościach ciągów, aby dobrze się bawić z widokiem świata ograniczonym polem / rekordem awk. Ale pozwala ci pozostać w wierszu poleceń, z większą poprawnością niż grep -o.

Na podstawie tego, że niektóre z rekomendacji (szczególnie w komentarzach) sugerowały użycie Pythona, byłem rozczarowany, że nie znalazłem przykładu.

Oto jeden linijka, aby uzyskać jedną wartość z niektórych danych JSON. Zakłada się, że przesyłasz dane skądś (skądś) i dlatego powinno być przydatne w kontekście skryptów.

echo '{"hostname":"test","domainname":"example.com"}' | python -c 'import json,sys;obj=json.load(sys.stdin);print obj["hostname"]'

Podążając za MartinR i Boecko:

$ curl -s 'http://twitter.com/users/username.json' | python -mjson.tool

To da ci wyjątkowo przyjazny efekt grep. Bardzo wygodne:

$ curl -s 'http://twitter.com/users/username.json' | python -mjson.tool | grep my_key

Możesz po prostu pobrać plik jqbinarny na swoją platformę i uruchomić ( chmod +x jq):

$ curl 'https://twitter.com/users/username.json' | ./jq -r '.name'

Wyodrębnia "name"atrybut z obiektu json.

jqstrona główna mówi, że jest tak jak w sedprzypadku danych JSON.

Korzystanie z Node.js

Jeśli system ma węzełPo zainstalowaniu można użyć flagi -pdrukowania i -eewaluacji skryptów, JSON.parseaby wyciągnąć dowolną potrzebną wartość.

Prosty przykład z wykorzystaniem ciągu JSON { "foo": "bar" }i wyciągnięcia wartości „foo”:

$ node -pe 'JSON.parse(process.argv[1]).foo' '{ "foo": "bar" }'
bar

Ponieważ mamy dostęp cati inne narzędzia, możemy użyć tego do plików:

$ node -pe 'JSON.parse(process.argv[1]).foo' "$(cat foobar.json)"
bar

Lub dowolny inny format, taki jak adres URL zawierający JSON:

$ node -pe 'JSON.parse(process.argv[1]).name' "$(curl -s https://api.github.com/users/trevorsenior)"
Trevor Senior

Użyj obsługi JSON w Pythonie zamiast awk!

Coś takiego:

curl -s http://twitter.com/users/username.json | \
    python -c "import json,sys;obj=json.load(sys.stdin);print obj['name'];"

Zapytałeś, jak strzelić sobie w stopę, a ja jestem tutaj, aby dostarczyć amunicję:

curl -s 'http://twitter.com/users/username.json' | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^text/ {print $2}'

Możesz użyć tr -d '{}'zamiast sed. Ale ich całkowite pominięcie wydaje się mieć również pożądany efekt.

Jeśli chcesz usunąć zewnętrzne cytaty, przeprowadź wynik powyższego sed 's/\(^"\|"$\)//g'

Myślę, że inni wydali wystarczający alarm. Będę stał przy telefonie komórkowym, żeby wezwać pogotowie. Strzelaj, gdy będziesz gotowy.

Używanie Bash z Pythonem

Utwórz funkcję bash w pliku .bash_rc

function getJsonVal () { 
    python -c "import json,sys;sys.stdout.write(json.dumps(json.load(sys.stdin)$1))"; 
}

Następnie

$ curl 'http://twitter.com/users/username.json' | getJsonVal "['text']"
My status
$ 

Oto ta sama funkcja, ale z kontrolą błędów.

function getJsonVal() {
   if [ \( $# -ne 1 \) -o \( -t 0 \) ]; then
       cat <<EOF
Usage: getJsonVal 'key' < /tmp/
 -- or -- 
 cat /tmp/input | getJsonVal 'key'
EOF
       return;
   fi;
   python -c "import json,sys;sys.stdout.write(json.dumps(json.load(sys.stdin)$1))";
}

Gdzie $ # -ne 1 zapewnia co najmniej 1 wejście, a -t 0 upewnia się, że przekierowujesz z potoku.

Zaletą tej implementacji jest to, że możesz uzyskać dostęp do zagnieżdżonych wartości json i otrzymać je w zamian! =)

Przykład:

$ echo '{"foo": {"bar": "baz", "a": [1,2,3]}}' |  getJsonVal "['foo']['a'][1]"
2

Jeśli chcesz być naprawdę fantazyjny, możesz wydrukować dane:

function getJsonVal () { 
    python -c "import json,sys;sys.stdout.write(json.dumps(json.load(sys.stdin)$1, sort_keys=True, indent=4))"; 
}

$ echo '{"foo": {"bar": "baz", "a": [1,2,3]}}' |  getJsonVal "['foo']"
{
    "a": [
        1, 
        2, 
        3
    ], 
    "bar": "baz"
}

TickTick to parser JSON napisany bash (<250 linii kodu)

Oto fragment autora z jego artykułu Wyobraź sobie świat, w którym Bash wspiera JSON :

#!/bin/bash
. ticktick.sh

``  
  people = { 
    "Writers": [
      "Rod Serling",
      "Charles Beaumont",
      "Richard Matheson"
    ],  
    "Cast": {
      "Rod Serling": { "Episodes": 156 },
      "Martin Landau": { "Episodes": 2 },
      "William Shatner": { "Episodes": 2 } 
    }   
  }   
``  

function printDirectors() {
  echo "  The ``people.Directors.length()`` Directors are:"

  for director in ``people.Directors.items()``; do
    printf "    - %s\n" ${!director}
  done
}   

`` people.Directors = [ "John Brahm", "Douglas Heyes" ] ``
printDirectors

newDirector="Lamont Johnson"
`` people.Directors.push($newDirector) ``
printDirectors

echo "Shifted: "``people.Directors.shift()``
printDirectors

echo "Popped: "``people.Directors.pop()``
printDirectors

Przetwarzanie JSON z PHP CLI

Prawdopodobnie nie na temat, ale skoro panuje pierwszeństwo, to pytanie pozostaje niepełne bez wzmianki o naszym zaufanym i wiernym PHP, czy mam rację?

Korzystając z tego samego przykładu JSON, ale pozwala przypisać go do zmiennej w celu zmniejszenia niejasności.

$ export JSON='{"hostname":"test","domainname":"example.com"}'

Teraz na dobroć PHP, używając file_get_contents i php: // stdin stream wrapper.

$ echo $JSON|php -r 'echo json_decode(file_get_contents("php://stdin"))->hostname;'

lub jak wskazano przy użyciu fgets i już otwartego strumienia przy stałej CLI STDIN .

$ echo $JSON|php -r 'echo json_decode(fgets(STDIN))->hostname;'

nJoy!

Wersja Native Bash: Działa również dobrze z odwrotnymi ukośnikami (\) i cudzysłowami („)

function parse_json()
{
    echo $1 | \
    sed -e 's/[{}]/''/g' | \
    sed -e 's/", "/'\",\"'/g' | \
    sed -e 's/" ,"/'\",\"'/g' | \
    sed -e 's/" , "/'\",\"'/g' | \
    sed -e 's/","/'\"---SEPERATOR---\"'/g' | \
    awk -F=':' -v RS='---SEPERATOR---' "\$1~/\"$2\"/ {print}" | \
    sed -e "s/\"$2\"://" | \
    tr -d "\n\t" | \
    sed -e 's/\\"/"/g' | \
    sed -e 's/\\\\/\\/g' | \
    sed -e 's/^[ \t]*//g' | \
    sed -e 's/^"//'  -e 's/"$//'
}


parse_json '{"username":"john, doe","email":"john@doe.com"}' username
parse_json '{"username":"john doe","email":"john@doe.com"}' email

--- outputs ---

john, doe
johh@doe.com

Wersja korzystająca z Ruby i http://flori.github.com/json/

$ < file.json ruby -e "require 'rubygems'; require 'json'; puts JSON.pretty_generate(JSON[STDIN.read]);"

lub bardziej zwięźle:

$ < file.json ruby -r rubygems -r json -e "puts JSON.pretty_generate(JSON[STDIN.read]);"

Niestety top głosowało odpowiedź, która używa grepZwraca pełny mecz, który nie działa w moim scenariuszu, ale jeśli wiesz, format JSON pozostanie na stałym można użyć lookbehind i uprzedzona wyodrębnić tylko pożądanych wartości.

# echo '{"TotalPages":33,"FooBar":"he\"llo","anotherValue":100}' | grep -Po '(?<="FooBar":")(.*?)(?=",)'
he\"llo
# echo '{"TotalPages":33,"FooBar":"he\"llo","anotherValue":100}' | grep -Po '(?<="TotalPages":)(.*?)(?=,)'
33
#  echo '{"TotalPages":33,"FooBar":"he\"llo","anotherValue":100}' | grep -Po '(?<="anotherValue":)(.*?)(?=})'
100

Jeśli ktoś chce tylko wyodrębnić wartości z prostych obiektów JSON bez potrzeby tworzenia struktur zagnieżdżonych, możliwe jest użycie wyrażeń regularnych bez opuszczania bash.

Oto funkcja, którą zdefiniowałem za pomocą wyrażeń regularnych bash opartych na standardzie JSON :

function json_extract() {
  local key=$1
  local json=$2

  local string_regex='"([^"\]|\\.)*"'
  local number_regex='-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?'
  local value_regex="${string_regex}|${number_regex}|true|false|null"
  local pair_regex="\"${key}\"[[:space:]]*:[[:space:]]*(${value_regex})"

  if [[ ${json} =~ ${pair_regex} ]]; then
    echo $(sed 's/^"\|"$//g' <<< "${BASH_REMATCH[1]}")
  else
    return 1
  fi
}

Ostrzeżenia: obiekty i tablice nie są obsługiwane jako wartość, ale obsługiwane są wszystkie inne typy wartości zdefiniowane w standardzie. Również para zostanie dopasowana bez względu na to, jak głęboko jest w dokumencie JSON, o ile ma dokładnie taką samą nazwę klucza.

Na przykładzie OP:

$ json_extract text "$(curl 'http://twitter.com/users/username.json')"
My status

$ json_extract friends_count "$(curl 'http://twitter.com/users/username.json')"
245

Jest łatwiejszy sposób na uzyskanie właściwości z ciągu Json. Korzystając z package.jsonpliku jako przykładu, spróbuj tego:

#!/usr/bin/env bash
my_val="$(json=$(<package.json) node -pe "JSON.parse(process.env.json)['version']")"

Używamy, process.envponieważ powoduje to umieszczenie zawartości pliku w node.js jako ciągu bez ryzyka, że ​​złośliwe treści umkną cytatom i zostaną przeanalizowane jako kod.

Teraz, gdy Powershell jest wieloplatformowy, pomyślałem, że tam pójdę, ponieważ uważam, że jest dość intuicyjny i niezwykle prosty.

curl -s 'https://api.github.com/users/lambda' | ConvertFrom-Json 

ConvertFrom-Json konwertuje JSON w niestandardowy obiekt Powershell, dzięki czemu można łatwo pracować z właściwościami od tego momentu. Jeśli na przykład chcesz tylko właściwości „id”, po prostu wykonaj następujące czynności:

curl -s 'https://api.github.com/users/lambda' | ConvertFrom-Json | select -ExpandProperty id

Jeśli chcesz wywołać całą rzecz z poziomu Basha, musisz nazwać to tak:

powershell 'curl -s "https://api.github.com/users/lambda" | ConvertFrom-Json'

Oczywiście istnieje czysty sposób Powershell, aby to zrobić bez zwijania się, co byłoby:

Invoke-WebRequest 'https://api.github.com/users/lambda' | select -ExpandProperty Content | ConvertFrom-Json

Wreszcie istnieje również „ConvertTo-Json”, który równie łatwo konwertuje obiekt niestandardowy do JSON. Oto przykład:

(New-Object PsObject -Property @{ Name = "Tester"; SomeList = @('one','two','three')}) | ConvertTo-Json

Który wytworzyłby fajny JSON w ten sposób:

{
"Name":  "Tester",
"SomeList":  [
                 "one",
                 "two",
                 "three"
             ]

}

Trzeba przyznać, że używanie powłoki Windows na Uniksie jest nieco świętokradcze, ale Powershell jest naprawdę dobry w niektórych rzeczach, a parsowanie JSON i XML to tylko niektóre z nich. To jest strona GitHub dla wersji międzyplatformowej https://github.com/PowerShell/PowerShell

Ktoś, kto ma również pliki XML, może chcieć spojrzeć na mój Xidel . Jest to cli, niezależny procesor JSONiq . (tzn. obsługuje także XQuery dla przetwarzania XML lub JSON)

Przykładem w pytaniu byłoby:

 xidel -e 'json("http://twitter.com/users/username.json")("name")'

Lub z moją własną, niestandardową składnią rozszerzenia:

 xidel -e 'json("http://twitter.com/users/username.json").name'

Nie mogę tutaj użyć żadnej z odpowiedzi. Brak dostępnych jq, żadnych tablic powłoki, bez deklarowania, bez grep -P, bez lookbehind i lookahead, bez Pythona, bez Perla, bez Ruby, nie - nawet Bash ... Pozostałe odpowiedzi po prostu nie działają dobrze. JavaScript brzmiał znajomo, ale puszka mówi Nescaffe - więc też nie ma wyjścia :) Nawet jeśli są dostępne, dla mojej prostej potrzeby - byłyby przesadne i powolne.

Jednak niezwykle ważne jest dla mnie uzyskanie wielu zmiennych z sformatowanej w formacie json odpowiedzi mojego modemu. Robię to w mgnieniu oka z bardzo przyciętym BusyBox na moich routerach! Nie ma problemów z używaniem samego awk: wystarczy ustawić ograniczniki i odczytać dane. Dla jednej zmiennej to wszystko!

awk 'BEGIN { FS="\""; RS="," }; { if ($2 == "login") {print $4} }' test.json

Pamiętasz, że nie mam tablic? Musiałem przypisać w analizowanym pliku awk 11 zmiennych, których potrzebuję w skrypcie powłoki. Gdziekolwiek spojrzałem, była to misja niemożliwa. Z tym też nie ma problemu.

Moje rozwiązanie jest proste. Ten kod: 1) parsuje plik .json z pytania (faktycznie pożyczyłem próbkę danych roboczych z najbardziej pozytywnej odpowiedzi) i wybrał cytowane dane, a także 2) tworzy zmienne powłoki z poziomu awk, przypisując dowolną nazwaną powłokę nazwy zmiennych.

eval $( curl -s 'https://api.github.com/users/lambda' | 
awk ' BEGIN { FS="\""; RS="," };
{
    if ($2 == "login") { print "Login=\""$4"\"" }
    if ($2 == "name") { print "Name=\""$4"\"" }
    if ($2 == "updated_at") { print "Updated=\""$4"\"" }
}' )
echo "$Login, $Name, $Updated"

Brak problemów z pustymi miejscami w środku. W moim zastosowaniu to samo polecenie analizuje długi wynik jednego wiersza. Ponieważ używana jest funkcja eval, to rozwiązanie jest odpowiednie tylko dla zaufanych danych. Łatwo jest dostosować go do pobierania niecytowanych danych. W przypadku ogromnej liczby zmiennych przyrost prędkości krańcowej można osiągnąć przy użyciu else if. Brak tablic oznacza oczywiście: brak wielu rekordów bez dodatkowego majstrowania. Ale tam, gdzie dostępne są tablice, dostosowanie tego rozwiązania jest prostym zadaniem.

@maikel sed odpowiedź prawie działa (ale nie mogę tego komentować). Dla moich ładnie sformatowanych danych - działa. Nie tyle w przykładzie tutaj użytym (brakujące cytaty go odrzucają). Jest to skomplikowane i trudne do modyfikacji. Ponadto nie lubię wykonywać 11 wywołań w celu wyodrębnienia 11 zmiennych. Dlaczego? Zmierzyłem czas 100 pętli wyodrębniając 9 zmiennych: funkcja sed zajęła 48,99 sekundy, a moje rozwiązanie zajęło 0,91 sekundy! Niesprawiedliwe? Wykonywanie tylko jednej ekstrakcji 9 zmiennych: 0,51 vs. 0,02 sek.

Możesz spróbować czegoś takiego -

curl -s 'http://twitter.com/users/jaypalsingh.json' | 
awk -F=":" -v RS="," '$1~/"text"/ {print}'

Możesz użyć jshon:

curl 'http://twitter.com/users/username.json' | jshon -e text

Oto jeden ze sposobów, w jaki możesz to zrobić za pomocą awk

curl -sL 'http://twitter.com/users/username.json' | awk -F"," -v k="text" '{
    gsub(/{|}/,"")
    for(i=1;i<=NF;i++){
        if ( $i ~ k ){
            print $i
        }
    }
}'

W przypadku bardziej złożonej analizy JSON sugeruję użycie modułu jsonpath w Pythonie (autor: Stefan Goessner) -

1. Zainstaluj to -

sudo easy_install -U jsonpath

1. Użyj tego -

Przykładowy plik.json (z http://goessner.net/articles/JsonPath ) -

{ "store": {
    "book": [ 
      { "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95
      },
      { "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99
      },
      { "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      { "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95
    }
  }
}

Parsuj (wyodrębnij wszystkie tytuły książek o cenie <10) -

$ cat file.json | python -c "import sys, json, jsonpath; print '\n'.join(jsonpath.jsonpath(json.load(sys.stdin), 'store.book[?(@.price < 10)].title'))"

Wyjdzie -

Sayings of the Century
Moby Dick

UWAGA: Powyższy wiersz poleceń nie obejmuje sprawdzania błędów. dla pełnego rozwiązania z kontrolą błędów powinieneś utworzyć mały skrypt Pythona i owinąć kod try-wyjątkiem.

Jeśli masz php :

php -r 'var_export(json_decode(`curl http://twitter.com/users/username.json`, 1));'

Na przykład:
mamy zasób, który zapewnia json z kodami ISO krajów: http://country.io/iso3.json i możemy go łatwo zobaczyć w powłoce z curl:

curl http://country.io/iso3.json

ale wygląda na niezbyt wygodny i nieczytelny, lepiej parsuj json i zobacz czytelną strukturę:

php -r 'var_export(json_decode(`curl http://country.io/iso3.json`, 1));'

Ten kod wyświetli coś takiego:

array (
  'BD' => 'BGD',
  'BE' => 'BEL',
  'BF' => 'BFA',
  'BG' => 'BGR',
  'BA' => 'BIH',
  'BB' => 'BRB',
  'WF' => 'WLF',
  'BL' => 'BLM',
  ...

jeśli zagnieżdżono tablice, dane wyjściowe będą wyglądały znacznie lepiej ...

Mam nadzieję, że to pomoże ...

Istnieje również bardzo proste, ale potężne narzędzie przetwarzania JSON CLI fx - https://github.com/antonmedv/fx

Przykłady

Użyj funkcji anonimowej:

$ echo '{"key": "value"}' | fx "x => x.key"
value

Jeśli nie przejdziesz funkcji anonimowej param => ..., kod zostanie automatycznie przekształcony w funkcję anonimową. Możesz uzyskać dostęp do JSON za pomocą tego słowa kluczowego:

$ echo '[1,2,3]' | fx "this.map(x => x * 2)"
[2, 4, 6]

Lub po prostu użyj składni kropkowej:

$ echo '{"items": {"one": 1}}' | fx .items.one
1

Możesz przekazać dowolną liczbę anonimowych funkcji zmniejszających JSON:

$ echo '{"items": ["one", "two"]}' | fx "this.items" "this[1]"
two

Możesz zaktualizować istniejący JSON za pomocą operatora spreadu:

$ echo '{"count": 0}' | fx "{...this, count: 1}"
{"count": 1}

Po prostu JavaScript . Nie musisz uczyć się nowej składni.

AKTUALIZACJA 2018-11-06

fxteraz ma tryb interaktywny ( ! )

https://github.com/antonmedv/fx

To jest kolejna bashi pythonhybrydowa odpowiedź. Wysłałem tę odpowiedź, ponieważ chciałem przetwarzać bardziej złożone dane wyjściowe JSON, ale zmniejszając złożoność mojej aplikacji bash. Chcę złamać następujący obiekt JSON z http://www.arcgis.com/sharing/rest/info?f=json w bash:

{
  "owningSystemUrl": "http://www.arcgis.com",
  "authInfo": {
    "tokenServicesUrl": "https://www.arcgis.com/sharing/rest/generateToken",
    "isTokenBasedSecurity": true
  }
}

W poniższym przykładzie utworzyłem własną implementację jqi unquotewykorzystanie python. Zauważysz, że po zaimportowaniu obiektu python jsondo słownika python możemy używać składni python do nawigacji w słowniku. Aby poruszać się po powyższym, składnia jest następująca:

• data
• data[ "authInfo" ]
• data[ "authInfo" ][ "tokenServicesUrl" ]

Używając magii w bash, pomijamy datai dostarczamy tylko tekst python po prawej stronie danych, tj

• jq
• jq '[ "authInfo" ]'
• jq '[ "authInfo" ][ "tokenServicesUrl" ]'

Uwaga, bez parametrów, jq działa jako prettifier JSON. Za pomocą parametrów możemy użyć składni Pythona, aby wyodrębnić wszystko, co chcemy ze słownika, w tym nawigację w słownikach i elementach tablicy.

Oto działający przykład, który pokazuje powyższe:

jq_py() {
cat <<EOF
import json, sys
data = json.load( sys.stdin )
print( json.dumps( data$1, indent = 4 ) )
EOF
}

jq() {
  python -c "$( jq_py "$1" )"
}

unquote_py() {
cat <<EOF
import json,sys
print( json.load( sys.stdin ) )
EOF
}

unquote() {
  python -c "$( unquote_py )"
}

curl http://www.arcgis.com/sharing/rest/info?f=json | tee arcgis.json
# {"owningSystemUrl":"https://www.arcgis.com","authInfo":{"tokenServicesUrl":"https://www.arcgis.com/sharing/rest/generateToken","isTokenBasedSecurity":true}}

cat arcgis.json | jq
# {
#     "owningSystemUrl": "https://www.arcgis.com",
#     "authInfo": {
#         "tokenServicesUrl": "https://www.arcgis.com/sharing/rest/generateToken",
#         "isTokenBasedSecurity": true
#     }
# }

cat arcgis.json | jq '[ "authInfo" ]'
# {
#     "tokenServicesUrl": "https://www.arcgis.com/sharing/rest/generateToken",
#     "isTokenBasedSecurity": true
# }

cat arcgis.json | jq '[ "authInfo" ][ "tokenServicesUrl" ]'
# "https://www.arcgis.com/sharing/rest/generateToken"

cat arcgis.json | jq '[ "authInfo" ][ "tokenServicesUrl" ]' | unquote
# https://www.arcgis.com/sharing/rest/generateToken

Zrobiłem to, „analizując” odpowiedź JSON dla określonej wartości, w następujący sposób:

curl $url | grep $var | awk '{print $2}' | sed s/\"//g 

Oczywiście, tutaj $ url będzie adresem URL Twittera, a $ var będzie „tekstem”, aby uzyskać odpowiedź na ten var.

Naprawdę, myślę, że jedyną rzeczą, którą robię OP, jest pominięcie grep dla linii z konkretną zmienną, której szuka. Awk chwyta drugi przedmiot w wierszu i za pomocą sed usuwam cytaty.

Ktoś mądrzejszy ode mnie prawdopodobnie byłby w stanie przemyśleć całą sprawę za pomocą awk lub grep.

Teraz możesz to wszystko zrobić za pomocą tylko sed:

curl $url | sed '/text/!d' | sed s/\"text\"://g | sed s/\"//g | sed s/\ //g

więc bez awk, bez grep ... Nie wiem, dlaczego wcześniej o tym nie myślałem. Hmmm...

Analiza JSON jest bolesna w skrypcie powłoki. Korzystając z bardziej odpowiedniego języka, utwórz narzędzie, które wyodrębni atrybuty JSON w sposób zgodny z konwencjami skryptowymi powłoki. Możesz użyć swojego nowego narzędzia, aby rozwiązać natychmiastowy problem ze skryptami powłoki, a następnie dodać go do zestawu na przyszłe sytuacje.

Na przykład rozważmy narzędzie jsonlookup takie, że jeśli powiem jsonlookup access token id, zwróci identyfikator atrybutu zdefiniowany w tokenie atrybutu zdefiniowanym w ramach dostępu do atrybutu ze standardowego wejścia, którym są prawdopodobnie dane JSON. Jeśli atrybut nie istnieje, narzędzie nic nie zwraca (status wyjścia 1). Jeśli parsowanie się nie powiedzie, wyjdź ze stanu 2 i wyślij wiadomość do stderr. Jeśli wyszukiwanie się powiedzie, narzędzie wydrukuje wartość atrybutu.

Po stworzeniu narzędzia uniksowego do precyzyjnego wyodrębniania wartości JSON, możesz łatwo używać go w skryptach powłoki:

access_token=$(curl <some horrible crap> | jsonlookup access token id)

Dowolny język zrobi dla implementacji jsonlookup . Oto dość zwięzła wersja Pythona:

#!/usr/bin/python                                                               

import sys
import json

try: rep = json.loads(sys.stdin.read())
except:
    sys.stderr.write(sys.argv[0] + ": unable to parse JSON from stdin\n")
    sys.exit(2)
for key in sys.argv[1:]:
    if key not in rep:
        sys.exit(1)
    rep = rep[key]
print rep

Dwuliniowy, który używa Pythona. Działa to szczególnie dobrze, jeśli piszesz pojedynczy plik .sh i nie chcesz polegać na innym pliku .py. Wykorzystuje również użycie rury |. echo "{\"field\": \"value\"}"można zastąpić czymkolwiek wypisującym json na standardowe wyjście.

echo "{\"field\": \"value\"}" | python -c 'import sys, json
print(json.load(sys.stdin)["field"])'

To dobry przypadek użycia dla pythonpy :

curl 'http://twitter.com/users/username.json' | py 'json.load(sys.stdin)["name"]'