Tableaux en

À propos de Tableaux

JSON définit un tableau ainsi :

Un tableau est une collection ordonnée de valeurs. Un tableau commence par un crochet gauche [ et se termine par un crochet droit ]. Les valeurs sont séparées par une virgule ,.

Un tableau peut contenir zéro ou plusieurs valeurs JSON de n'importe quel type. Il n'est pas nécessaire que les éléments d'un tableau soient tous du même type.

Crée des tableaux

Utilise des crochets pour rassembler des éléments dans un tableau.

[1, 2, 3]

On peut capturer les éléments d'un flux dans un tableau en l'entourant de crochets.

range(5)     # => a stream of 5 numbers
[range(5)]   # => the array [0, 1, 2, 3, 4]

Taille

La fonction length renvoie le nombre d'éléments d'un tableau.

Indices et tranches

L'indexation des tableaux commence à zéro.

Pour récupérer un élément d'un tableau, utilise une expression entre crochets : .[2] renvoie le troisième élément.

Les indices négatifs se comptent à partir de la fin du tableau : .[-1] renvoie le dernier élément ; .[-2] renvoie l'avant-dernier.

Une tranche est une sous-séquence du tableau. .[10:15] renvoie 5 éléments à partir de l'indice 10 ; l'indice de fin n'est pas inclus.

Il existe quelques fonctions pratiques :

• first renvoie le premier élément.
• last renvoie le dernier élément.
• nth(n) renvoie l'élément à l'indice n.

Convertir en flux d'éléments

Il y a des situations où l'on souhaite obtenir un flux avec les éléments d'un tableau, un par un. Pour cela, on utilise .[].

Supposons que l'on veuille un flux contenant les longueurs des strings d'un tableau.

["a", "be", "cat", "door"] | length        # => 4 -- the number of elements in the array
["a", "be", "cat", "door"] | .[] | length  # => 1, 2, 3, 4 -- the lengths of each element

On peut placer les crochets vides à côté de l'expression précédente, en omettant le pipe.

["a", "be", "cat", "door"][] | length      # => 1, 2, 3, 4 -- the lengths of each element
# ........................^^

Concaténation et soustraction

Utilise + pour concaténer des tableaux.

[1, 2, 3] + [4, 5]          # => [1, 2, 3, 4, 5]

L'opérateur - retire du tableau de gauche les éléments présents dans le tableau de droite.

[range(10)] - [2, 4, 6]     # => [0, 1, 3, 5, 7, 8, 9]

Itération

jq fournit de nombreuses fonctions qui couvrent les besoins courants d'itération :

• map(expr) renvoie un nouveau tableau dans lequel expr est appliqué successivement à chaque élément.

  [1, 2, 3] | map(. * 10)    # => [10, 20, 30]
  
  

• select(expr) est une fonction qui applique expr à une valeur unique ; si le résultat de l'expression est vrai, alors la valeur est renvoyée ; si le résultat est faux, rien n'est renvoyé : pas null, vraiment rien.

  Pour l'appliquer à un tableau, combine-la avec map.

  [range(10)] | map(select(. % 2 == 0))    # => [0, 2, 4, 6, 8]
  

  Autrement, applique select à un flux et rassemble les résultats.

  [range(10) | select(. % 2 == 0)]    # => [0, 2, 4, 6, 8]
  

• any(condition) et all(condition) renvoient une valeur booléenne indiquant si au moins un élément, ou tous les éléments, du tableau satisfont la condition.

  [1, 2, 3, 4] | any(. > 4)    # false
  [1, 2, 3, 4] | any(. >= 4)   # true
  
  [1, 2, 3, 4] | all(. >= 4)   # false
  [1, 2, 3, 4] | all(. <= 4)   # true
  

Appartenance

On peut vérifier qu'un tableau contient un élément avec index. Cette fonction renvoie l'indice de l'élément donné s'il est présent dans le tableau ; sinon, elle renvoie null.

["carrots", "beef", "potatoes"] | index("beef")    # => 1
["carrots", "beef", "potatoes"] | index("bees")    # => null

Il existe une fonction inverse appelée IN (oui, en majuscules). La subtilité avec IN, c'est que son argument n'est pas un tableau, mais un flux.

"beef" | IN(["carrots", "beef", "potatoes"][])    # => true
"bees" | IN(["carrots", "beef", "potatoes"][])    # => false

Autres fonctions (voir le manuel pour plus de détails)

• Ruby dispose d'une méthode pratique each_with_index qui associe la valeur de chaque élément à son indice. Python a enumerate. jq propose quelque chose de similaire, appelé to_entries. Cette fonction transforme le tableau en un tableau d'objets {key: index, value: value}.

  [11, 22, 33, 44] | to_entries
  # => [{key: 0, value: 11}, {key: 1, value: 22}, {key: 2, value: 33}, {key: 3, value: 44}]
  

• sort et sort_by

• group_by

• min, max, min_by, max_by

• unique, unique_by

• flatten