Conversion d'un objet JSON en un tableau associatif Bash

J'ai un script Bash. Il récupère les données en JSON.
J'ai besoin de convertir le tableau JSON d'un tableau Bash.

Exemple

{
  "SALUTATION": "Hello world",
  "SOMETHING": "bla bla bla Mr. Freeman"
}

En Bash je veux obtenir une valeur comme cela echo ${arr[SOMETHING]}.

source d'informationauteur Evgenii

  1. 15

    Si vous voulez une clé et une valeur, et sur la base Comment faire pour convertir un objet json à la clé=valeur de format dans JQvous pouvez le faire:

    $ jq -r "to_entries|map(\"\(.key)=\(.value|tostring)\")|.[]" file
SALUTATION=Hello world
SOMETHING=bla bla bla Mr. Freeman

    D'une manière plus générale, vous pouvez stocker les valeurs dans un tableau myarray[key] = value comme ça, juste en fournissant jq à la while avec le while ... do; ... done < <(command) syntaxe:

    declare -A myarray
while IFS="=" read -r key value
do
    myarray[$key]="$value"
done < <(jq -r "to_entries|map(\"\(.key)=\(.value)\")|.[]" file)

    Et puis vous pouvez faire une boucle à travers les valeurs comme ceci:

    for key in "${!myarray[@]}"
do
    echo "$key = ${myarray[$key]}"
done

    Pour cette entrée donnée, il retourne:

    SALUTATION = Hello world
SOMETHING = bla bla bla Mr. Freeman
  2. 7

    Contexte: Cette réponse a été rédigée de manière à être sensible à une question de titre qui n'existe plus..

    L'OP question en fait décrit des objets, vs tableaux.

    Pour être sûr que nous aider d'autres personnes à venir qui sont fait à la recherche pour obtenir de l'aide avec JSON tableaux, cependant, il vaut la peine de les couvrir explicitement.

    Pour le coffre-ish cas où les chaînes ne peuvent pas contenir des retours à la ligne (et quand bash 4.0 ou plus récent), cela fonctionne:

    str='["Hello world", "bla bla bla Mr. Freeman"]'
readarray -t array <<<"$(jq -r '.[]' <<<"$str")"

    À prendre en charge les anciennes versions de bash, et les chaînes de caractères avec des sauts de ligne, nous obtenons un peu plus évolué, à l'aide d'un NUL délimité par des flux de lire à partir de jq:

    str='["Hello world", "bla bla bla Mr. Freeman", "this is\ntwo lines"]'
array=( )
while IFS= read -r -d '' line; do
  array+=( "$line" )
done < <(jq -j '.[] | (. + "\u0000")')
  3. 1

    C'est comment peut-il être fait de manière récursive:

    #!/bin/bash

SOURCE="$PWD"
SETTINGS_FILE="$SOURCE/settings.json"
SETTINGS_JSON=`cat "$SETTINGS_FILE"`

declare -A SETTINGS

function get_settings() {
    local PARAMS="$#"
    local JSON=`jq -r "to_entries|map(\"\(.key)=\(.value|tostring)\")|.[]" <<< "$1"`
    local KEYS=''

    if [ $# -gt 1 ]; then
        KEYS="$2"
    fi

    while read -r PAIR; do
        local KEY=''

        if [ -z "$PAIR" ]; then
            break
        fi

        IFS== read PAIR_KEY PAIR_VALUE <<< "$PAIR"

        if [ -z "$KEYS" ]; then
            KEY="$PAIR_KEY"
        else
            KEY="$KEYS:$PAIR_KEY"
        fi

        if jq -e . >/dev/null 2>&1 <<< "$PAIR_VALUE"; then
            get_settings "$PAIR_VALUE" "$KEY"
        else
            SETTINGS["$KEY"]="$PAIR_VALUE"
        fi
    done <<< "$JSON"
}

    L'appeler:

    get_settings "$SETTINGS_JSON"

    Le tableau sera accessible comme suit:

    ${SETTINGS[grandparent:parent:child]}
  4. 0

    Pour charger objet JSON dans un bash tableau associatif efficacement (sans l'aide de boucles en bash), on peut utiliser l'outil "jq", comme suit. 

    # first, load the json text into a variable:
json='{"SALUTATION": "Hello world", "SOMETHING": "bla bla bla Mr. Freeman"}'

# then, prepare associative array, I use 'aa':
unset aa
declare -A aa

# use jq to produce text defining name:value pairs in the bash format
# using @sh to properly escape the values
aacontent=$(jq -r '. | to_entries | .[] | "[\"" + .key + "\"]=" + (.value | @sh)' <<< "$json")

# string containing whole definition of aa in bash
aadef="aa=($aacontent)"

# load the definition (because values may contain LF characters, aadef must be in double quotes)
eval "$aadef"

# now we can access the values like this: echo "${aa[SOMETHING]}"

    Avertissement: il utilise eval, ce qui est dangereux si le json entrée est de source inconnue (peut contenir des commandes shell qui eval peut exécuter).