Analyser JSON avec les outils Unix

J'essaie d'analyser le JSON renvoyé d'une demande de boucle, comme ceci:

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

Ce qui précède divise le JSON en champs, par exemple:

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

Comment imprimer un champ spécifique (indiqué par le -v k=text)?

Il existe un certain nombre d'outils spécialement conçus pour manipuler JSON à partir de la ligne de commande, et seront beaucoup plus faciles et plus fiables que de le faire avec Awk, tels que jq:

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

Vous pouvez également le faire avec des outils qui sont probablement déjà installés sur votre système, comme Python en utilisant le jsonmodule , et ainsi éviter toute dépendance supplémentaire, tout en bénéficiant d'un analyseur JSON approprié. Ce qui suit suppose que vous souhaitez utiliser UTF-8, dans lequel le JSON d'origine doit être codé et c'est ce que la plupart des terminaux modernes utilisent également:

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

Notes historiques

Cette réponse recommandait à l'origine jsawk , qui devrait toujours fonctionner, mais est un peu plus lourd à utiliser que jq, et dépend d'un interpréteur JavaScript autonome en cours d'installation qui est moins courant qu'un interprète Python, donc les réponses ci-dessus sont probablement préférables:

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

Cette réponse a également utilisé à l'origine l'API Twitter de la question, mais cette API ne fonctionne plus, ce qui rend difficile la copie des exemples à tester, et la nouvelle API Twitter nécessite des clés d'API, j'ai donc basculé vers l'utilisation de l'API GitHub qui peut être utilisé facilement sans clés API. La première réponse à la question d'origine serait:

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

Pour extraire rapidement les valeurs d'une clé particulière, j'aime personnellement utiliser "grep -o", qui ne renvoie que la correspondance de l'expression régulière. Par exemple, pour obtenir le champ "texte" des tweets, quelque chose comme:

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

Cette expression régulière est plus robuste que vous ne le pensez; par exemple, il traite très bien les chaînes ayant des virgules intégrées et des guillemets échappés à l'intérieur. Je pense qu'avec un peu plus de travail, vous pourriez en faire un qui soit garanti d'extraire la valeur, s'il est atomique. (S'il a une imbrication, un regex ne peut pas le faire bien sûr.)

Et pour nettoyer plus (mais en gardant Escaping originale de la chaîne) , vous pouvez utiliser quelque chose comme: | perl -pe 's/"text"://; s/^"//; s/",$//'. (Je l'ai fait pour cette analyse .)

Pour tous les ennemis qui insistent sur le fait que vous devriez utiliser un véritable analyseur JSON - oui, c'est essentiel pour l'exactitude, mais

1. Pour effectuer une analyse très rapide, comme compter les valeurs pour vérifier les bogues de nettoyage des données ou avoir une idée générale des données, il est plus rapide de frapper quelque chose sur la ligne de commande. Ouvrir un éditeur pour écrire un script est distrayant.
2. grep -oest un ordre de grandeur plus rapide que la jsonbibliothèque standard Python , du moins lors de cette opération pour les tweets (qui font environ 2 Ko chacun). Je ne sais pas si c'est juste parce que jsonc'est lent (je devrais comparer avec yajl un jour); mais en principe, une expression régulière devrait être plus rapide car elle est à l'état fini et beaucoup plus optimisable, au lieu d'un analyseur qui doit prendre en charge la récursivité, et dans ce cas, dépense beaucoup d'arbres de construction CPU pour les structures qui ne vous intéressent pas. (Si quelqu'un écrivait un transducteur à états finis qui effectuait une analyse JSON appropriée (limitée en profondeur), ce serait fantastique! En attendant, nous avons "grep -o".)

Pour écrire du code maintenable, j'utilise toujours une vraie bibliothèque d'analyse. Je n'ai pas essayé jsawk , mais si cela fonctionne bien, cela répondrait au point # 1.

Une dernière solution, plus farfelue: j'ai écrit un script qui utilise Python jsonet extrait les clés que vous voulez, dans des colonnes séparées par des tabulations; puis je passe à travers un wrapper awkqui permet un accès nommé aux colonnes. Ici: les scripts json2tsv et tsvawk . Donc pour cet exemple ce serait:

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

Cette approche ne prend pas en compte le # 2, est plus inefficace qu'un seul script Python, et elle est un peu fragile: elle force la normalisation des sauts de ligne et des tabulations dans les valeurs de chaîne, pour bien jouer avec la vue du monde délimitée par les enregistrements / champs d'AWK. Mais cela vous permet de rester sur la ligne de commande, avec plus d'exactitude que grep -o.

Sur la base que certaines des recommandations ici (en particulier dans les commentaires) suggéraient l'utilisation de Python, j'ai été déçu de ne pas trouver d'exemple.

Donc, voici une ligne pour obtenir une valeur unique à partir de certaines données JSON. Il suppose que vous canalisez les données (de quelque part) et devrait donc être utile dans un contexte de script.

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

Suivant l'exemple de MartinR et Boecko:

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

Cela vous donnera une sortie extrêmement conviviale pour grep. Très pratique:

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

Vous pouvez simplement télécharger le jqbinaire pour votre plate - forme et exécuter ( chmod +x jq):

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

Il extrait l' "name"attribut de l'objet json.

jqla page d'accueil dit que c'est comme sedpour les données JSON.

Utilisation de Node.js

Si le système a nœudinstallé, il est possible d'utiliser les indicateurs de script -pprint et -eevaulate avec JSON.parsepour extraire toute valeur nécessaire.

Un exemple simple utilisant la chaîne JSON { "foo": "bar" }et extrayant la valeur de "foo":

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

Étant donné que nous avons accès à d' catautres utilitaires, nous pouvons les utiliser pour les fichiers:

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

Ou tout autre format tel qu'une URL contenant du JSON:

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

Utilisez le support JSON de Python au lieu d'utiliser awk!

Quelque chose comme ça:

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

Vous avez demandé comment vous tirer une balle dans le pied et je suis ici pour fournir les munitions:

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

Vous pouvez utiliser à la tr -d '{}'place de sed. Mais les laisser complètement de côté semble également avoir l'effet souhaité.

Si vous souhaitez supprimer les guillemets extérieurs, canalisez le résultat de ce qui précède à travers sed 's/\(^"\|"$\)//g'

Je pense que d'autres ont suffisamment sonné l'alarme. Je serai avec un téléphone portable pour appeler une ambulance. Tirez quand vous êtes prêt.

Utiliser Bash avec Python

Créez une fonction bash dans votre fichier .bash_rc

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

alors

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

Voici la même fonction, mais avec vérification des erreurs.

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

Où $ # -ne 1 garantit au moins 1 entrée et -t 0 vous assure que vous redirigez depuis un tube.

La bonne chose à propos de cette implémentation est que vous pouvez accéder aux valeurs json imbriquées et obtenir json en retour! =)

Exemple:

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

Si vous voulez être vraiment fantaisiste, vous pouvez imprimer les données:

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 est un analyseur JSON écrit en bash (<250 lignes de code)

Voici l'extrait de l'auteur de son article, Imaginez un monde où Bash prend en charge 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

Analyser JSON avec PHP CLI

Sans doute hors sujet, mais puisque la priorité règne, cette question reste incomplète sans mentionner notre PHP fidèle et fidèle, ai-je raison?

En utilisant le même exemple JSON mais permet de l'affecter à une variable pour réduire l'obscurité.

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

Maintenant pour la qualité PHP, en utilisant file_get_contents et le wrapper de flux php: // stdin .

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

ou comme indiqué en utilisant fgets et le flux déjà ouvert à la constante CLI STDIN .

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

nJoy!

Version native de Bash: fonctionne également bien avec les barres obliques inverses (\) et les guillemets (")

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

Version qui utilise Ruby et http://flori.github.com/json/

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

ou plus concis:

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

Malheureusement , la réponse qui a voté top utilisations greprenvoie le plein match qui n'a pas fonctionné dans mon scénario, mais si vous connaissez le format JSON reste constante , vous pouvez utiliser lookbehind et préanalyse pour extraire uniquement les valeurs souhaitées.

# 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

Si quelqu'un veut simplement extraire des valeurs à partir d'objets JSON simples sans avoir besoin de structures imbriquées, il est possible d'utiliser des expressions régulières sans même quitter le bash.

Voici une fonction que j'ai définie en utilisant des expressions régulières bash basées sur la norme 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
}

Avertissements: les objets et les tableaux ne sont pas pris en charge en tant que valeur, mais tous les autres types de valeur définis dans la norme sont pris en charge. En outre, une paire sera mise en correspondance, quelle que soit la profondeur dans le document JSON, tant qu'elle a exactement le même nom de clé.

En utilisant l'exemple d'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

Il existe un moyen plus simple d'obtenir une propriété à partir d'une chaîne json. En utilisant un package.jsonfichier comme exemple, essayez ceci:

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

Nous utilisons process.envcar cela obtient le contenu du fichier dans node.js sous forme de chaîne sans aucun risque de contenu malveillant échappant à leur citation et analysé en tant que code.

Maintenant que Powershell est multiplateforme, je pensais que j'allais me lancer là-bas, car je le trouve assez intuitif et extrêmement simple.

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

ConvertFrom-Json convertit le JSON en un objet personnalisé Powershell, de sorte que vous pouvez facilement travailler avec les propriétés à partir de ce point. Si vous vouliez seulement la propriété 'id' par exemple, vous feriez juste ceci:

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

Si vous vouliez invoquer le tout depuis Bash, alors vous devriez l'appeler comme ceci:

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

Bien sûr, il existe une manière Powershell pure de le faire sans boucle, qui serait:

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

Enfin, il existe également 'ConvertTo-Json' qui convertit tout aussi facilement un objet personnalisé en JSON. Voici un exemple:

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

Ce qui produirait un joli JSON comme celui-ci:

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

}

Certes, l'utilisation d'un shell Windows sur Unix est quelque peu sacrilège, mais Powershell est vraiment bon dans certaines choses, et l'analyse JSON et XML en sont quelques-unes. Ceci est la page GitHub pour la version multiplateforme https://github.com/PowerShell/PowerShell

Quelqu'un qui a également des fichiers xml, voudra peut-être regarder mon Xidel . Il s'agit d'un processeur JSONiq sans cli et sans dépendance . (c'est-à-dire qu'il prend également en charge XQuery pour le traitement xml ou json)

L'exemple dans la question serait:

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

Ou avec ma propre syntaxe d'extension non standard:

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

Je ne peux utiliser aucune des réponses ici. Pas de jq disponible, pas de tableaux de shell, pas de déclaration, pas de grep -P, pas de lookbehind et lookahead, pas de Python, pas de Perl, pas de Ruby, non - pas même Bash ... Les réponses restantes ne fonctionnent tout simplement pas bien. JavaScript semblait familier, mais l'étain dit Nescaffe - donc c'est non plus :) Même si disponible, pour mon simple besoin - ils seraient exagérés et lents.

Pourtant, il est extrêmement important pour moi d'obtenir de nombreuses variables de la réponse au format json de mon modem. Je le fais dans un sh avec BusyBox très coupé vers le bas à mes routeurs! Aucun problème en utilisant awk seul: il suffit de définir des délimiteurs et de lire les données. Pour une seule variable, c'est tout!

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

Rappelez-vous que je n'ai pas de tableaux? J'ai dû affecter dans les données analysées awk aux 11 variables dont j'ai besoin dans un script shell. Partout où je regardais, c'était une mission impossible. Pas de problème avec ça aussi.

Ma solution est simple. Ce code va: 1) analyser le fichier .json de la question (en fait, j'ai emprunté un échantillon de données de travail à la réponse la plus votée) et sélectionner les données citées, plus 2) créer des variables de shell à l'intérieur de l'awk en attribuant un shell nommé gratuit noms de variables.

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"

Aucun problème avec les blancs à l'intérieur. Dans mon utilisation, la même commande analyse une sortie longue ligne unique. Comme eval est utilisé, cette solution convient uniquement aux données fiables. Il est simple de l'adapter à la collecte de données non cotées. Pour un grand nombre de variables, un gain de vitesse marginal peut être obtenu en utilisant else if. Manque de tableau signifie évidemment: pas d'enregistrements multiples sans bidouilles supplémentaires. Mais là où des baies sont disponibles, l'adaptation de cette solution est une tâche simple.

@maikel sed répond presque fonctionne (mais je ne peux pas en parler). Pour mes données bien formatées - cela fonctionne. Pas tellement avec l'exemple utilisé ici (les guillemets manquants le jettent). C'est compliqué et difficile à modifier. De plus, je n'aime pas avoir à faire 11 appels pour extraire 11 variables. Pourquoi? J'ai chronométré 100 boucles en extrayant 9 variables: la fonction sed a pris 48,99 secondes et ma solution a pris 0,91 secondes! Pas juste? Faire une seule extraction de 9 variables: 0,51 contre 0,02 s.

Vous pouvez essayer quelque chose comme ça -

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

Vous pouvez utiliser jshon:

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

voici une façon de le faire avec 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
        }
    }
}'

Pour une analyse JSON plus complexe, je suggère d'utiliser le module python jsonpath (par Stefan Goessner) -

1. Installez-le -

sudo easy_install -U jsonpath

1. Utilise le -

Exemple de fichier.json (depuis 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
    }
  }
}

Analyser (extraire tous les titres de livres avec un prix <10) -

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

Sortira -

Sayings of the Century
Moby Dick

REMARQUE: la ligne de commande ci-dessus n'inclut pas la vérification des erreurs. pour une solution complète avec vérification des erreurs, vous devez créer un petit script python et encapsuler le code avec try-except.

Si vous avez php :

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

Par exemple:
nous avons une ressource qui fournit à json les codes iso des pays: http://country.io/iso3.json et nous pouvons facilement le voir dans un shell avec curl:

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

mais cela ne semble pas très pratique et pas lisible, mieux analyser json et voir la structure lisible:

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

Ce code imprimera quelque chose comme:

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

si vous avez des tableaux imbriqués, cette sortie sera bien meilleure ...

J'espère que cela vous sera utile ...

Il existe également un outil de traitement JSON CLI très simple mais puissant fx - https://github.com/antonmedv/fx

Exemples

Utilisez une fonction anonyme:

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

Si vous ne transmettez pas la fonction anonyme param => ..., le code sera automatiquement transformé en fonction anonyme. Et vous pouvez accéder à JSON par ce mot-clé:

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

Ou utilisez également la syntaxe par points:

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

Vous pouvez transmettre un nombre illimité de fonctions anonymes pour réduire JSON:

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

Vous pouvez mettre à jour le JSON existant à l'aide de l'opérateur d'étalement:

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

Tout simplement JavaScript . Pas besoin d'apprendre une nouvelle syntaxe.

MISE À JOUR 2018-11-06

fxa maintenant le mode interactif ( ! )

https://github.com/antonmedv/fx

Ceci est encore une autre bashet pythonréponse hybride. J'ai posté cette réponse parce que je voulais traiter une sortie JSON plus complexe, mais en réduisant la complexité de mon application bash. Je souhaite ouvrir l'objet JSON suivant à partir de http://www.arcgis.com/sharing/rest/info?f=json dans bash:

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

Dans l'exemple suivant, j'ai créé ma propre implémentation jqet unquoteoptimisation python. Vous remarquerez qu'une fois que nous importons l'objet python depuis jsondans un dictionnaire python, nous pouvons utiliser la syntaxe python pour naviguer dans le dictionnaire. Pour naviguer dans ce qui précède, la syntaxe est la suivante:

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

En utilisant la magie dans bash, nous omettons dataet ne fournissons que le texte python à droite des données, c'est-à-dire

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

Notez, sans paramètres, jqagit comme un prettifier JSON. Avec les paramètres, nous pouvons utiliser la syntaxe python pour extraire tout ce que nous voulons du dictionnaire, y compris la navigation dans les sous-répertoires et les éléments de tableau.

Voici un exemple de travail qui illustre ce qui précède:

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

J'ai fait cela, "analysant" une réponse json pour une valeur particulière, comme suit:

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

Clairement, $ url ici serait l'url de twitter, et $ var serait "text" pour obtenir la réponse pour cette var.

Vraiment, je pense que la seule chose que je fais l'OP a laissé de côté est grep pour la ligne avec la variable spécifique qu'il cherche. Awk saisit le deuxième élément de la ligne et avec sed, je supprime les guillemets.

Quelqu'un plus intelligent que moi pourrait probablement penser le tout avec awk ou grep.

Maintenant, vous pouvez tout faire avec simplement sed:

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

donc pas d'awk, pas de grep ... Je ne sais pas pourquoi je n'y avais pas pensé avant. Hmmm ...

L'analyse JSON est pénible dans un script shell. Avec un langage plus approprié, créez un outil qui extrait les attributs JSON d'une manière cohérente avec les conventions de script shell. Vous pouvez utiliser votre nouvel outil pour résoudre le problème immédiat de script shell et l'ajouter ensuite à votre kit pour des situations futures.

Par exemple, considérons un outil jsonlookup tel que si je dis jsonlookup access token idqu'il renverra l' ID d' attribut défini dans le jeton d' attribut défini dans l' accès d' attribut de stdin, qui est vraisemblablement des données JSON. Si l'attribut n'existe pas, l'outil ne renvoie rien (quitter le statut 1). Si l'analyse échoue, quittez l'état 2 et un message à stderr. Si la recherche réussit, l'outil imprime la valeur de l'attribut.

Après avoir créé un outil Unix dans le but précis d'extraire des valeurs JSON, vous pouvez facilement l'utiliser dans des scripts shell:

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

N'importe quel langage fera l'affaire pour l'implémentation de jsonlookup . Voici une version python assez concise:

#!/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 deux lignes qui utilise du python. Cela fonctionne particulièrement bien si vous écrivez un seul fichier .sh et que vous ne voulez pas dépendre d'un autre fichier .py. Il tire également parti de l'utilisation des tuyaux |. echo "{\"field\": \"value\"}"peut être remplacé par tout ce qui imprime un json sur la sortie standard.

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

C'est un bon cas d' utilisation pour pythonpy :

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