Analisi di JSON con strumenti Unix

Sto cercando di analizzare JSON restituito da una richiesta di arricciatura, in questo modo:

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]}'

Quanto sopra divide il JSON in campi, ad esempio:

% ...
"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
% ...

Come si stampa un campo specifico (indicato da -v k=text)?

Esistono numerosi strumenti appositamente progettati allo scopo di manipolare JSON dalla riga di comando e saranno molto più semplici e affidabili rispetto a Awk, come ad esempio jq:

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

Puoi anche farlo con strumenti che probabilmente sono già installati sul tuo sistema, come Python usando il jsonmodulo , e quindi evitare eventuali dipendenze extra, pur avendo il vantaggio di un parser JSON adeguato. Quanto segue presuppone che tu voglia usare UTF-8, in cui dovrebbe essere codificato il JSON originale ed è quello che usano anche i terminali più moderni:

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']"

Note storiche

Questa risposta originariamente raccomandava jsawk , che dovrebbe ancora funzionare, ma è un po 'più complicato da usare rispetto a jq, e dipende dall'installazione di un interprete JavaScript autonomo che è meno comune di un interprete Python, quindi le risposte sopra sono probabilmente preferibili:

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

Questa risposta originariamente utilizzava anche l'API di Twitter dalla domanda, ma quell'API non funziona più, rendendo difficile la copia degli esempi da testare e la nuova API di Twitter richiede chiavi API, quindi sono passato all'utilizzo dell'API GitHub che può essere utilizzato facilmente senza chiavi API. La prima risposta alla domanda originale sarebbe:

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

Per estrarre rapidamente i valori di una chiave particolare, personalmente mi piace usare "grep -o", che restituisce solo la corrispondenza della regex. Ad esempio, per ottenere il campo "testo" dai tweet, qualcosa del tipo:

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

Questa regex è più robusta di quanto si possa pensare; ad esempio, si occupa di stringhe con virgole incorporate e virgolette sfuggite al loro interno. Penso che con un po 'più di lavoro potresti realizzarne uno che è effettivamente garantito per estrarre il valore, se è atomico. (Se ha nidificazione, quindi un regex non può farlo ovviamente.)

E per ulteriori pulita (seppur mantenendo fuga originale della stringa) si può usare qualcosa come: | perl -pe 's/"text"://; s/^"//; s/",$//'. (L'ho fatto per questa analisi .)

A tutti gli odiatori che insistono che dovresti usare un vero parser JSON - sì, questo è essenziale per la correttezza, ma

1. Per eseguire un'analisi davvero rapida, come contare i valori per controllare i bug di pulizia dei dati o avere un'idea generale dei dati, sbattere qualcosa sulla riga di comando è più veloce. Aprire un editor per scrivere una sceneggiatura è fonte di distrazione.
2. grep -oè ordini di grandezza più veloci della jsonlibreria standard Python , almeno quando lo si fa per i tweet (che sono ~ 2 KB ciascuno). Non sono sicuro se questo è solo perché jsonè lento (dovrei confrontarmi con yajl qualche volta); ma in linea di principio, un regex dovrebbe essere più veloce poiché è stato finito e molto più ottimizzabile, invece di un parser che deve supportare la ricorsione, e in questo caso, spende un sacco di alberi di CPU per le strutture che non ti interessano. (Se qualcuno scrivesse un trasduttore di stato finito che eseguiva un corretto analisi JSON (limitata in profondità), sarebbe fantastico! Nel frattempo abbiamo "grep -o".)

Per scrivere codice gestibile, utilizzo sempre una vera libreria di analisi. Non ho provato jsawk , ma se funziona bene, si tratterebbe del punto 1.

Un'ultima soluzione più stravagante: ho scritto uno script che utilizza Python jsoned estrae le chiavi desiderate in colonne separate da tabulazioni; poi passo attraverso un wrapper awkche consente l'accesso denominato alle colonne. Qui: gli script json2tsv e tsvawk . Quindi per questo esempio sarebbe:

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

Questo approccio non si rivolge al n. 2, è più inefficiente di un singolo script Python ed è un po 'fragile: forza la normalizzazione di nuove righe e tabulazioni nei valori di stringa, per giocare bene con la visione del mondo delimitata da campo / record. Ma ti consente di rimanere sulla riga di comando, con più correttezza di grep -o.

Sulla base del fatto che alcune delle raccomandazioni qui riportate (in particolare nei commenti) hanno suggerito l'uso di Python, sono rimasto deluso dal non trovare un esempio.

Quindi, ecco una riga per ottenere un singolo valore da alcuni dati JSON. Presuppone che tu stia eseguendo il piping dei dati (da qualche parte) e quindi dovrebbe essere utile in un contesto di scripting.

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

Seguendo l'esempio di MartinR e Boecko:

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

Questo ti darà un risultato estremamente amichevole. Molto conveniente:

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

Potresti semplicemente scaricare jqbinario per la tua piattaforma ed eseguire ( chmod +x jq):

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

Estrae l' "name"attributo dall'oggetto json.

jqhomepage dice che è come sedper i dati JSON.

Utilizzando Node.js

Se il sistema ha nodoinstallato, è possibile utilizzare i flag di script -pprint ed -eevaulate JSON.parseper estrarre qualsiasi valore necessario.

Un semplice esempio usando la stringa JSON { "foo": "bar" }ed estraendo il valore di "pippo":

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

Poiché abbiamo accesso catae altre utilità, possiamo usarlo per i file:

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

O qualsiasi altro formato come un URL che contiene JSON:

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

Usa il supporto JSON di Python invece di usare awk!

Qualcosa come questo:

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

Hai chiesto come spararti al piede e sono qui per fornire le munizioni:

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

È possibile utilizzare tr -d '{}'invece di sed. Ma lasciarli completamente fuori sembra avere anche l'effetto desiderato.

Se si desidera eliminare le virgolette esterne, reindirizzare il risultato di cui sopra sed 's/\(^"\|"$\)//g'

Penso che altri abbiano suonato un allarme sufficiente. Starò con un telefono cellulare per chiamare un'ambulanza. Spara quando sei pronto.

Utilizzo di Bash con Python

Crea una funzione bash nel tuo file .bash_rc

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

Poi

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

Ecco la stessa funzione, ma con controllo degli errori.

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))";
}

Dove $ # -ne 1 si assicura almeno 1 input e -t 0 si assicura che si stia reindirizzando da una pipe.

La cosa bella di questa implementazione è che puoi accedere ai valori json nidificati e ottenere json in cambio! =)

Esempio:

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

Se vuoi essere davvero fantasioso, potresti piuttosto stampare i dati:

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 è un parser JSON scritto in bash (<250 righe di codice)

Ecco lo snippit dell'autore dal suo articolo, Immagina un mondo in cui Bash supporta 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

Analisi di JSON con CLI PHP

Probabilmente fuori tema, ma poiché regna la precedenza questa domanda rimane incompleta senza menzionare il nostro fidato e fedele PHP, ho ragione?

Utilizzando lo stesso esempio JSON, ma consente di assegnarlo a una variabile per ridurre l'oscurità.

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

Ora per la bontà di PHP, usando file_get_contents e il wrapper stream php: // stdin .

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

o come sottolineato usando i budget e il flusso già aperto nella costante CLI STDIN .

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

nJoy!

Versione nativa di Bash: funziona bene anche con barre rovesciate (\) e virgolette (")

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

Versione che utilizza Ruby e http://flori.github.com/json/

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

o più concisamente:

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

Sfortunatamente la risposta più votata che utilizza greprestituisce la corrispondenza completa che non ha funzionato nel mio scenario, ma se sai che il formato JSON rimarrà costante puoi usare lookbehind e lookahead per estrarre solo i valori desiderati.

# 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

Se qualcuno vuole semplicemente estrarre valori da semplici oggetti JSON senza la necessità di strutture nidificate, è possibile usare espressioni regolari senza nemmeno lasciare la bash.

Ecco una funzione che ho definito usando espressioni regolari bash basate sullo standard 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
}

Avvertenze: gli oggetti e le matrici non sono supportati come valore, ma sono supportati tutti gli altri tipi di valore definiti nello standard. Inoltre, una coppia verrà abbinata indipendentemente dalla profondità del documento JSON purché abbia esattamente lo stesso nome chiave.

Utilizzando l'esempio di 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

C'è un modo più semplice per ottenere una proprietà da una stringa JSON. Usando un package.jsonfile come esempio, prova questo:

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

Lo stiamo usando process.envperché questo porta i contenuti del file in node.js come una stringa senza il rischio che i contenuti dannosi sfuggano al loro preventivo e vengano analizzati come codice.

Ora che Powershell è multipiattaforma, ho pensato di farmi strada là fuori, dal momento che trovo che sia abbastanza intuitivo ed estremamente semplice.

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

ConvertFrom-Json converte JSON in un oggetto personalizzato Powershell, in modo da poter lavorare facilmente con le proprietà da quel punto in avanti. Se, ad esempio, si desidera solo la proprietà "id", è sufficiente:

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

Se volessi invocare il tutto dall'interno di Bash, allora dovresti chiamarlo così:

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

Naturalmente c'è un modo puro Powershell per farlo senza arricciatura, che sarebbe:

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

Infine, c'è anche 'ConvertTo-Json' che converte un oggetto personalizzato in JSON altrettanto facilmente. Ecco un esempio:

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

Che produrrebbe un bel JSON in questo modo:

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

}

Certo, usare una shell di Windows su Unix è un po 'sacrilego, ma Powershell è davvero bravo in alcune cose, e l'analisi di JSON e XML ne è un paio. Questa è la pagina GitHub per la versione multipiattaforma https://github.com/PowerShell/PowerShell

Qualcuno che ha anche file XML, potrebbe voler guardare il mio Xidel . È un processore JSONiq cli, privo di dipendenze . (ovvero supporta anche XQuery per l'elaborazione xml o json)

L'esempio nella domanda sarebbe:

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

O con la mia sintassi di estensione non standard:

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

Non posso usare nessuna delle risposte qui. Nessun jq disponibile, nessun array di shell, nessuna dichiarazione, nessun grep -P, nessun lookbehind e lookahead, nessun Python, nessun Perl, nessun Ruby, no - nemmeno Bash ... Le restanti risposte semplicemente non funzionano bene. JavaScript sembrava familiare, ma la scatola dice Nescaffe - quindi è un non andare anche :) :) Anche se disponibili, per la mia semplice necessità - sarebbero eccessivi e lenti.

Tuttavia, è estremamente importante per me ottenere molte variabili dalla risposta in formato json del mio modem. Lo sto facendo in un attimo con BusyBox molto ridotto sui miei router! Nessun problema usando solo awk: basta impostare i delimitatori e leggere i dati. Per una singola variabile, tutto qui!

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

Ricordi che non ho array? Ho dovuto assegnare all'interno dei dati analizzati awk alle 11 variabili di cui ho bisogno in uno script di shell. Ovunque guardassi, si diceva che fosse una missione impossibile. Nessun problema anche con quello.

La mia soluzione è semplice Questo codice: 1) analizzerà il file .json dalla domanda (in realtà, ho preso in prestito un campione di dati di lavoro dalla risposta più votata) e selezionerà i dati citati, più 2) creerà le variabili della shell all'interno del awk assegnando la shell denominata libera nomi di variabili.

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"

Nessun problema con gli spazi vuoti all'interno. Nel mio uso, lo stesso comando analizza un output a riga singola lunga. Poiché viene utilizzato eval, questa soluzione è adatta solo per dati affidabili. È semplice adattarlo per raccogliere dati non quotati. Per un numero enorme di variabili, il guadagno di velocità marginale può essere ottenuto usando altro se. La mancanza di array ovviamente significa: nessun record multiplo senza armeggiare ulteriormente. Ma laddove sono disponibili array, l'adattamento di questa soluzione è un compito semplice.

@maikel sed answer funziona quasi (ma non posso commentarlo). Per i miei dati ben formattati, funziona. Non tanto con l'esempio usato qui (le virgolette mancanti lo scaricano). È complicato e difficile da modificare. Inoltre, non mi piace dover effettuare 11 chiamate per estrarre 11 variabili. Perché? Ho cronometrato 100 loop estraendo 9 variabili: la funzione sed ha richiesto 48,99 secondi e la mia soluzione ha impiegato 0,91 secondi! Non è giusto? Eseguendo una sola estrazione di 9 variabili: 0,51 vs. 0,02 sec.

Puoi provare qualcosa del genere -

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

Puoi usare jshon:

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

ecco un modo in cui puoi farlo con 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
        }
    }
}'

Per analisi JSON più complesse suggerisco di usare il modulo jsonpath di Python (di Stefan Goessner) -

1. Installalo -

sudo easy_install -U jsonpath

1. Usalo -

Esempio file.json (da 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
    }
  }
}

Analizzalo (estrai tutti i titoli di libri con un prezzo <10) -

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

Verrà emesso -

Sayings of the Century
Moby Dick

NOTA: la riga di comando sopra non include il controllo degli errori. per una soluzione completa con controllo degli errori è necessario creare un piccolo script Python e racchiudere il codice con try-tranne.

Se hai php :

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

Ad esempio:
abbiamo una risorsa che fornisce a json i codici iso dei paesi: http://country.io/iso3.json e possiamo facilmente vederlo in una shell con curl:

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

ma non sembra molto conveniente, e non leggibile, meglio analizzare json e vedere la struttura leggibile:

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

Questo codice stamperà qualcosa del tipo:

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

se hai matrici nidificate questo output avrà un aspetto molto migliore ...

Spero che questo sia utile ...

Esiste anche uno strumento di elaborazione CLI JSON molto semplice ma potente fx - https://github.com/antonmedv/fx

Esempi

Usa la funzione anonima:

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

Se non si passa alla funzione anonima param => ..., il codice verrà automaticamente trasformato in funzione anonima. E puoi ottenere l'accesso a JSON con questa parola chiave:

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

Oppure usa anche la sintassi del punto:

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

È possibile passare un numero qualsiasi di funzioni anonime per ridurre JSON:

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

È possibile aggiornare JSON esistente utilizzando l'operatore spread:

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

Semplicemente JavaScript . Non è necessario imparare una nuova sintassi.

AGGIORNAMENTO 2018-11-06

fxora ha la modalità interattiva ( ! )

https://github.com/antonmedv/fx

Questo è un altro bashe pythonrisposta ibrido. Ho pubblicato questa risposta perché volevo elaborare un output JSON più complesso, ma riducendo la complessità della mia applicazione bash. Voglio aprire il seguente oggetto JSON da http://www.arcgis.com/sharing/rest/info?f=json in bash:

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

Nel seguente esempio, ho creato la mia implementazione jqe unquotesfruttamento python. Noterai che una volta importato l'oggetto Python da jsonun dizionario Python, possiamo usare la sintassi di Python per navigare nel dizionario. Per navigare sopra, la sintassi è:

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

Usando magic in bash, omettiamo datae forniamo il testo di Python solo a destra dei dati, ad es

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

Nota, senza parametri, jqfunge da prettificatore JSON. Con i parametri possiamo usare la sintassi di Python per estrarre dal dizionario tutto ciò che desideriamo, inclusi i dizionari di navigazione e gli elementi dell'array.

Ecco un esempio funzionante che dimostra quanto sopra:

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

Ho fatto questo, "analizzando" una risposta json per un valore particolare, come segue:

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

Chiaramente, $ url qui sarebbe l'url di Twitter, e $ var sarebbe "text" per ottenere la risposta per quel var.

Davvero, penso che l'unica cosa che sto facendo l'OP abbia lasciato fuori sia grep per la linea con la variabile specifica che cerca. Awk afferra il secondo oggetto sulla linea e con sed spoglio le virgolette.

Qualcuno più intelligente di me potrebbe probabilmente pensare tutto con awk o grep.

Ora, potresti fare tutto con solo sed:

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

quindi, no awk, no grep ... Non so perché non ci avevo pensato prima. Hmmm ...

L'analisi di JSON è dolorosa in uno script di shell. Con un linguaggio più appropriato, creare uno strumento che estrae gli attributi JSON in modo coerente con le convenzioni di shell scripting. È possibile utilizzare il nuovo strumento per risolvere il problema immediato di scripting della shell e quindi aggiungerlo al kit per situazioni future.

Ad esempio, considera uno strumento jsonlookup tale che se dico jsonlookup access token idrestituirà l' ID attributo definito all'interno del token dell'attributo definito all'interno dell'accesso all'attributo da stdin, che è presumibilmente dati JSON. Se l'attributo non esiste, lo strumento non restituisce nulla (stato di uscita 1). Se l'analisi non riesce, uscire dallo stato 2 e un messaggio a stderr. Se la ricerca ha esito positivo, lo strumento stampa il valore dell'attributo.

Dopo aver creato uno strumento unix allo scopo preciso di estrarre valori JSON, è possibile utilizzarlo facilmente negli script di shell:

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

Qualsiasi linguaggio farà per l'implementazione di jsonlookup . Ecco una versione abbastanza concisa di Python:

#!/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

Un liner che usa il pitone. Funziona particolarmente bene se stai scrivendo un singolo file .sh e non vuoi dipendere da un altro file .py. Sfrutta anche l'uso del tubo |. echo "{\"field\": \"value\"}"può essere sostituito da qualsiasi cosa stia stampando un json sullo stdout.

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

Questo è un buon esempio per pythonpy :

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