Créer JSON à l'aide de jq de canalisations séparées des clés et des valeurs dans bash

Préalable

Pour l'ensemble de la ci-dessous, il est supposé que votre contenu est dans une variable d'environnement nommée s:

s='CONTAINER|CPU%|MEMUSAGE/LIMIT|MEM%|NETI/O|BLOCKI/O|PIDS
nginx_container|0.02%|25.09MiB/15.26GiB|0.16%|0B/0B|22.09MB/4.096kB|0'

Ce moderne (jq)

# thanks to @JeffMercado and @chepner for refinements, see comments
jq -Rn '
( input  | split("|") ) as $keys |
( inputs | split("|") ) as $vals |
[[$keys, $vals] | transpose[] | {key:.[0],value:.[1]}] | from_entries
' <<<"$s"

Comment moderne (jq)

Cela nécessite de très nouveau (probablement de 1,5?) jq de travail, et un épais morceau de code. Pour le décomposer:

• À l'aide de -n empêche jq à partir de la lecture de l'entrée standard stdin sur son propre, en laissant l'intégralité des flux d'entrée disponibles pour être lu par input et inputs - le premier pour lire une seule ligne, et le dernier à lire toutes les lignes restantes. (-R, pour les matières premières d'entrée, les causes textuelle des lignes plutôt que des objets JSON pour être lu).
• Avec [$keys, $vals] | transpose[], nous générons de [key, value] paires (en Python termes, la compression de deux listes).
• Avec {key:.[0],value:.[1]}, nous faisons chaque [key, value] paire dans un objet de la forme {"key": key, "value": value}
• Avec from_entries, nous combinons ces paires d'objets contenant les clés et les valeurs.

---

Ce (shell assistée)

Cela fonctionne avec un beaucoup plus âgés jq que ci-dessus, et est facilement approche qui a été retenue pour les cas où un natifjq solution peut être plus difficile de se quereller:

{
   IFS='|' read -r -a keys # read first line into an array of strings

   ## read each subsequent line into an array named "values"
   while IFS='|' read -r -a values; do

    # setup: positional arguments to pass in literal variables, query with code    
    jq_args=( )
    jq_query='.'

    # copy values into the arguments, reference them from the generated code    
    for idx in "${!values[@]}"; do
        [[ ${keys[$idx]} ]] || continue # skip values with no corresponding key
        jq_args+=( --arg "key$idx"   "${keys[$idx]}"   )
        jq_args+=( --arg "value$idx" "${values[$idx]}" )
        jq_query+=" | .[$key${idx}]=$value${idx}"
    done

    # run the generated command
    jq "${jq_args[@]}" "$jq_query" <<<'{}'
  done
} <<<"$s"

---

Comment (shell assistée)

La invoquée jq commande à partir de ci-dessus est similaire à:

jq --arg key0   'CONTAINER' \
   --arg value0 'nginx_container' \
   --arg key1   'CPU%' \
   --arg value1 '0.0.2%' \
   --arg key2   'MEMUSAGE/LIMIT' \
   --arg value2 '25.09MiB/15.26GiB' \
   '. | .[$key0]=$value0 | .[$key1]=$value1 | .[$key2]=$value2' \
   <<<'{}'

...en passant chaque clé et de la valeur de la bande (telle qu'elle est traitée comme une chaîne littérale plutôt que analysée comme JSON), puis se référant à eux individuellement.

---

Résultat

Les émettent:

{
  "CONTAINER": "nginx_container",
  "CPU%": "0.02%",
  "MEMUSAGE/LIMIT": "25.09MiB/15.26GiB",
  "MEM%": "0.16%",
  "NETI/O": "0B/0B",
  "BLOCKI/O": "22.09MB/4.096kB",
  "PIDS": "0"
}

---

Pourquoi

En bref: Car il est garanti que pour générer du JSON valide en tant que sortie.

Considèrent comme un exemple de pause plus naïf approches:

s='key ending in a backslash\
value "with quotes"'

Sûr, ce sont des scénarios inattendus, mais jq sait comment traiter avec eux:

{
  "key ending in a backslash\\": "value \"with quotes\""
}

...alors qu'une mise en œuvre qui ne comprennent pas de chaînes JSON pourrait facilement se retrouver émettant:

{
  "key ending in a backslash\": "value "with quotes""
}

OriginalL'auteur Charles Duffy

Voici une solution qui utilise le -R et -s options, ainsi que transposer:

   split("\n")                       # [ "CONTAINER...", "nginx_container|0.02%...", ...]
 | (.[0]    | split("|")) as $keys   # [ "CONTAINER", "CPU%", "MEMUSAGE/LIMIT", ... ]
 | (.[1:][] | split("|"))            # [ "nginx_container", "0.02%", ... ] [ ... ] ...
 | select(length > 0)                # (remove empty [] caused by trailing newline)
 | [$keys, .]                        # [ ["CONTAINER", ...], ["nginx_container", ...] ] ...
 | [ transpose[] | {(.[0]):.[1]} ]   # [ {"CONTAINER": "nginx_container"}, ... ] ...
 | add                               # {"CONTAINER": "nginx_container", "CPU%": "0.02%" ...

OriginalL'auteur jq170727

Si vous êtes débutant avec les données tabulaires, je pense qu'il est plus logique d'utiliser quelque chose qui fonctionne avec des données tabulaires en natif, comme sqawk à faire en json, et ensuite utiliser jq travailler avec elle.

echo 'CONTAINER|CPU%|MEMUSAGE/LIMIT|MEM%|NETI/O|BLOCKI/O|PIDS
nginx_container|0.02%|25.09MiB/15.26GiB|0.16%|0B/0B|22.09MB/4.096kB|0' \
        | sqawk -FS '[|]' -RS '\n' -output json 'select * from a' header=1 \
        | jq '.[] | with_entries(select(.key|test("^a.*")|not))'

    {
      "CONTAINER": "nginx_container",
      "CPU%": "0.02%",
      "MEMUSAGE/LIMIT": "25.09MiB/15.26GiB",
      "MEM%": "0.16%",
      "NETI/O": "0B/0B",
      "BLOCKI/O": "22.09MB/4.096kB",
      "PIDS": "0"
    }

Sans jq, sqawk donne un peu trop:

[
  {
    "anr": "1",
    "anf": "7",
    "a0": "nginx_container|0.02%|25.09MiB/15.26GiB|0.16%|0B/0B|22.09MB/4.096kB|0",
    "CONTAINER": "nginx_container",
    "CPU%": "0.02%",
    "MEMUSAGE/LIMIT": "25.09MiB/15.26GiB",
    "MEM%": "0.16%",
    "NETI/O": "0B/0B",
    "BLOCKI/O": "22.09MB/4.096kB",
    "PIDS": "0",
    "a8": "",
    "a9": "",
    "a10": ""
  }
]

OriginalL'auteur MatrixManAtYrService