0Pricing
Linux Command Line & Bash Scripting Mastery · Leçon

Filtrer et sélectionner du JSON avec les pipelines jq

Parcourez des objets et des tableaux imbriqués à l’aide des sélecteurs, des tubes et du filtre select de jq.

Filtrer et sélectionner du JSON avec les pipelines jq est une leçon Linux Command Line & Bash Scripting Mastery gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Linux Command Line & Bash Scripting Mastery, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Linux Command Line & Bash Scripting Mastery comprend 4 leçons au total.

Qu’est-ce que jq et pourquoi l’utiliser ?

jq est un outil en ligne de commande léger et puissant qui permet d’analyser, de filtrer et de transformer des données JSON. C’est le sed du JSON : vous lui transmettez du JSON via un pipeline et récupérez une sortie structurée.

  • Préinstallé dans la plupart des distributions Linux ou disponible via apt install jq / brew install jq
  • Fonctionne parfaitement dans les pipelines de l’interpréteur avec curl, cat et d’autres outils
  • Prend en charge le filtrage, la mise en correspondance, la réduction et la conversion de format

L’appel de base est le suivant : jq '<filter>' file.json ou, avec un pipeline, cat file.json | jq '<filter>'. Le filtre . (point) est l’identité : il affiche l’intégralité du document avec une mise en forme lisible.

# Pretty-print a JSON file
jq '.' data.json

# Or pipe from curl
curl -s https://api.github.com/users/torvalds | jq '.'

Sélectionner des champs d’objet avec la notation par points

Pour accéder à un champ d’un objet JSON, utilisez la notation par points : .fieldName. Vous pouvez enchaîner les sélecteurs pour parcourir des objets imbriqués.

  • .name — champ de niveau supérieur
  • .address.city — champ imbriqué
  • ."field-with-dash" — les champs contenant des caractères spéciaux nécessitent des guillemets

Si le champ n’existe pas, jq renvoie null au lieu de produire une erreur. Vous pouvez ainsi l’utiliser sans risque dans des scripts, sans vérifications supplémentaires de la valeur nulle pour les champs facultatifs.

# Given: {"name":"Alice","address":{"city":"Berlin","zip":"10115"}}
echo '{"name":"Alice","address":{"city":"Berlin","zip":"10115"}}' | jq '.name'
# Output: "Alice"

echo '{"name":"Alice","address":{"city":"Berlin","zip":"10115"}}' | jq '.address.city'
# Output: "Berlin"

Accéder aux éléments d’un tableau et les parcourir

On accède aux tableaux JSON avec la notation entre crochets. jq utilise une indexation commençant à zéro.

  • .items[0] — premier élément
  • .items[-1] — dernier élément
  • .items[1:3] — tranche (de l’index 1 jusqu’avant l’index 3)
  • .items[] — déployer le tableau : produit chaque élément comme une valeur distincte (il s’agit de l’itérateur)

L’itérateur [] est fondamental dans les pipelines jq : il permet d’appliquer les filtres suivants à chaque élément indépendamment.

# Given an array of users
echo '[{"name":"Alice"},{"name":"Bob"},{"name":"Carol"}]' | jq '.[0]'
# Output: {"name":"Alice"}

# Iterate all elements and extract .name from each
echo '[{"name":"Alice"},{"name":"Bob"},{"name":"Carol"}]' | jq '.[].name'
# Output:
# "Alice"
# "Bob"
# "Carol"

Construire des pipelines jq avec l’opérateur de pipeline

Tout comme le pipeline de l’interpréteur |, jq possède son propre opérateur de pipeline interne. Celui-ci transmet la sortie d’un filtre comme entrée du suivant.

  • jq '.users[] | .name' — parcourir les utilisateurs, puis extraire le nom de chacun
  • jq '.data | .items[] | .id' — accéder aux données, déployer les éléments, puis extraire l’identifiant

Les pipelines à l’intérieur d’une expression jq permettent de construire des transformations complexes étape par étape. Chaque étape reçoit tout ce que l’étape précédente a produit, y compris plusieurs valeurs provenant d’un itérateur.

Point essentiel : lorsqu’un itérateur produit N valeurs, chaque filtre en aval s’exécute N fois, une fois par valeur.

# Nested pipeline: navigate -> iterate -> extract
echo '{"users":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}' \
  | jq '.users[] | .name'
# Output:
# "Alice"
# "Bob"

# Chain more stages
echo '{"users":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}' \
  | jq '.users[] | .age'
# Output:
# 30
# 25

Filtrer avec select()

Le filtre select(condition) ne laisse passer une valeur que si la condition est vraie ; sinon, il ne produit aucune sortie. C’est l’équivalent jq de grep ou de WHERE en SQL.

  • select(.age > 18) — conserver les objets dont l’âge est supérieur à 18
  • select(.status == "active") — vérifier l’égalité
  • select(.name | startswith("A")) — tester une chaîne imbriquée

Combinez select avec l’itérateur pour filtrer des tableaux : .items[] | select(.active) ne produit que les éléments pour lesquels .active est évalué comme vrai.

# Filter array elements by a condition
echo '[{"name":"Alice","age":30},{"name":"Bob","age":17},{"name":"Carol","age":25}]' \
  | jq '.[] | select(.age >= 18) | .name'
# Output:
# "Alice"
# "Carol"

# Filter by string equality
echo '[{"name":"Alice","role":"admin"},{"name":"Bob","role":"user"}]' \
  | jq '.[] | select(.role == "admin") | .name'
# Output: "Alice"

Reconstruire des objets et des tableaux avec {} et []

jq vous permet de remodeler les données en construisant de nouveaux objets avec {} et de nouveaux tableaux avec [].

  • {name: .name, city: .address.city} — sélectionner et renommer des champs dans un nouvel objet
  • [.items[] | .id] — rassembler les valeurs parcourues dans un nouveau tableau
  • Forme abrégée : {name, age} équivaut à {name: .name, age: .age}

Entourer un pipeline de [...] s’appelle une construction de tableau et est essentiel lorsque vous voulez obtenir un tableau JSON en sortie plutôt qu’un flux de valeurs.

# Reshape: keep only selected fields
echo '[{"id":1,"name":"Alice","password":"secret"},{"id":2,"name":"Bob","password":"secret"}]' \
  | jq '[.[] | {id, name}]'
# Output:
# [
#   {"id": 1, "name": "Alice"},
#   {"id": 2, "name": "Bob"}
# ]

# Collect filtered names into an array
echo '[{"name":"Alice","active":true},{"name":"Bob","active":false}]' \
  | jq '[.[] | select(.active) | .name]'
# Output: ["Alice"]

Travailler avec des tableaux imbriqués et une descente récursive

Les données JSON du monde réel sont souvent profondément imbriquées. jq fournit deux outils pour parcourir des structures en profondeur :

  • .a.b.c — chemin explicite lorsque la structure est connue
  • .. | .fieldName? — descente récursive : parcourt chaque nœud de l’arbre et produit les valeurs lorsque la clé existe

L’opérateur ? (tentative) supprime les erreurs lorsqu’un champ n’existe pas sur un nœud donné, ce qui est essentiel lors de l’utilisation de la descente récursive sur des arbres hétérogènes.

Utilisez la descente récursive avec modération sur les documents volumineux : elle visite chaque nœud et peut être lente. Préférez les chemins explicites lorsque la structure est prévisible.

# Explicit deep path
echo '{"a":{"b":{"c":42}}}' | jq '.a.b.c'
# Output: 42

# Recursive descent: find all "id" values anywhere in the tree
echo '{"users":[{"id":1,"profile":{"id":99}},{"id":2}]}' \
  | jq '.. | .id?'
# Output:
# 1
# 99
# 2

Exemple pratique : analyser les réponses d’une API avec curl

L’un des cas d’utilisation les plus courants de jq consiste à analyser les réponses d’API REST récupérées avec curl. Associer curl -s (mode silencieux) à un pipeline jq permet d’extraire des données propres et faciles à utiliser dans des scripts.

  • Extraire une valeur unique : curl -s URL | jq '.field'
  • Construire un tableau récapitulatif : parcourir un tableau et reconstruire des objets avec uniquement les champs nécessaires
  • Utiliser -r (sortie brute) pour retirer les guillemets qui entourent les valeurs de type chaîne — indispensable lors de l’affectation à des variables de l’interpréteur

Conseil : ajoutez toujours -r lorsque la sortie de jq doit être utilisée comme variable de l’interpréteur ou transmise à une autre commande.

#!/usr/bin/env bash
# Fetch GitHub repo info and extract specific fields
REPO="torvalds/linux"
RESPONSE=$(curl -s "https://api.github.com/repos/${REPO}")

# Extract fields
STARS=$(echo "$RESPONSE" | jq -r '.stargazers_count')
LANG=$(echo  "$RESPONSE" | jq -r '.language')
DESC=$(echo  "$RESPONSE" | jq -r '.description')

echo "Stars : $STARS"
echo "Lang  : $LANG"
echo "Desc  : $DESC"

Utiliser map() et map_values()

jq fournit deux fonctions d’ordre supérieur pratiques pour transformer des collections :

  • map(f) — applique le filtre f à chaque élément d’un tableau et renvoie un nouveau tableau. Équivaut à [.[] | f].
  • map_values(f) — applique f à chaque valeur d’un objet ou d’un tableau, en conservant les clés et les indices.

Ces fonctions sont plus lisibles que l’encapsulation manuelle de pipelines dans [] et correspondent au style idiomatique de jq pour les transformations qui doivent rester des tableaux.

# map: extract a field from each element
echo '[{"name":"Alice","score":95},{"name":"Bob","score":80}]' \
  | jq 'map(.name)'
# Output: ["Alice", "Bob"]

# map with select: filter + transform in one step
echo '[{"name":"Alice","score":95},{"name":"Bob","score":60}]' \
  | jq 'map(select(.score >= 70) | .name)'
# Output: ["Alice"]

# map_values: multiply every value in an object by 2
echo '{"a":1,"b":2,"c":3}' | jq 'map_values(. * 2)'
# Output: {"a":2,"b":4,"c":6}

Gérer les champs facultatifs et les valeurs par défaut avec //

Les données JSON provenant de sources externes sont souvent incohérentes : certains champs peuvent être absents ou nuls. jq fournit l’opérateur d’alternative // (double barre oblique) pour fournir une valeur par défaut.

  • .nickname // "anonymous" — utiliser .nickname si sa valeur n’est ni nulle ni fausse ; sinon utiliser "anonymous"
  • .count // 0 — valeur numérique par défaut
  • Combiner avec select : select((.status // "inactive") == "active")

Cette solution est bien plus concise que l’équivalent dans l’interpréteur, ${VAR:-default}, et se combine facilement au sein de pipelines plus longs.

# Provide defaults for missing/null fields
echo '[{"name":"Alice","role":"admin"},{"name":"Bob"}]' \
  | jq '[.[] | {name, role: (.role // "user")}]'
# Output:
# [
#   {"name": "Alice", "role": "admin"},
#   {"name": "Bob",   "role": "user"}
# ]

# Numeric default
echo '{"items":[1,2,3]}' | jq '.total // 0'
# Output: 0

Script pratique : analyseur de journaux JSON

La journalisation JSON structurée est devenue la norme dans les systèmes modernes. Voici un script réaliste qui lit un fichier de journal JSON délimité par des retours à la ligne, filtre les entrées d’erreur et met en forme un résumé lisible par une personne.

Principaux modèles utilisés :

  • -c (sortie compacte) — un objet JSON par ligne, pratique pour transmettre les données à des boucles de l’interpréteur
  • --arg name value — injecter une variable de l’interpréteur comme argument jq de type chaîne
  • select pour filtrer selon le niveau du journal
  • -r pour obtenir une sortie brute de type chaîne adaptée à echo
#!/usr/bin/env bash
# Parse newline-delimited JSON logs and report ERRORs
# Each log line: {"level":"ERROR","msg":"...","ts":"2024-01-15T10:23:00Z","svc":"auth"}

LOG_FILE="/var/log/app/app.log"
LEVEL="ERROR"

echo "=== $LEVEL entries in $LOG_FILE ==="

jq -r --arg lvl "$LEVEL" \
  'select(.level == $lvl) | "[\(.ts)] [\(.svc)] \(.msg)"' \
  "$LOG_FILE"

# Count errors per service
echo ""
echo "=== Error count by service ==="
jq -r --arg lvl "$LEVEL" \
  'select(.level == $lvl) | .svc' "$LOG_FILE" \
  | sort | uniq -c | sort -rn

Vérification des connaissances : comportement de select() dans une chaîne jq

Vérifiez votre compréhension du fonctionnement de select() dans une chaîne jq.

Étant donné la commande suivante :

echo '[{"name":"Alice","age":30},{"name":"Bob","age":17},{"name":"Carol","age":22}]' | jq '[.[] | select(.age >= 18) | .name]'

Quelle sera la sortie ?

Récapitulatif de la leçon : chaînes jq pour filtrer du JSON

Vous avez étudié les principaux outils jq pour parcourir et filtrer du JSON depuis la ligne de commande :

  • Notation avec points (.field, .a.b.c) pour sélectionner des champs dans des objets
  • Accès aux tableaux (.[0], .[]) pour indexer les tableaux et les parcourir
  • Opérateur de canalisation (|) pour enchaîner les filtres ; chaque étape traite toutes les valeurs de l’étape précédente
  • select(cond) filtre les valeurs et ne transmet que celles pour lesquelles la condition est vraie
  • Construction d’objets et de tableaux ({}, [], map()) pour remodeler les données en nouvelles structures
  • Opérateur alternatif (//) pour fournir des valeurs par défaut lorsque des champs sont nuls ou absents
  • Option -r pour supprimer les guillemets lors de l’affectation à une variable shell ; --arg pour injecter des variables shell de manière sûre
  • Parcours récursif (.. | .field?) pour rechercher dans des arborescences profondément imbriquées lorsque le chemin est inconnu

Avec ces éléments de base, vous pouvez transformer n’importe quelle réponse d’API JSON, fichier de journal ou configuration en exactement les données dont vos scripts ont besoin, sans jamais quitter le terminal.

Questions Fréquemment Posées

La leçon « Filtrer et sélectionner du JSON avec les pipelines jq » est-elle gratuite ?

Oui — le texte complet de « Filtrer et sélectionner du JSON avec les pipelines jq » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Linux Command Line & Bash Scripting Mastery, passe à CoddyKit PRO. Le cours Linux Command Line & Bash Scripting Mastery comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Filtrer et sélectionner du JSON avec les pipelines jq » ?

Parcourez des objets et des tableaux imbriqués à l’aide des sélecteurs, des tubes et du filtre select de jq. Tu pratiques Linux Command Line & Bash Scripting Mastery avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Linux Command Line & Bash Scripting Mastery ?

Aucune expérience préalable n'est requise. Linux Command Line & Bash Scripting Mastery sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Filtrer et sélectionner du JSON avec les pipelines jq » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Linux Command Line & Bash Scripting Mastery ?

Oui. Chaque leçon Linux Command Line & Bash Scripting Mastery inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Filtrer et sélectionner du JSON avec les pipelines jq
  2. Transformer et construire des objets JSON avec jq
  3. Consommer des API REST avec curl et jq
  4. Modifier des fichiers de configuration YAML avec yq
← Retour à Linux Command Line & Bash Scripting Mastery