Agrégation avec les tableaux et le regroupement dans awk

Dans awk, un tableau associatif est un magasin clé-valeur dont les clés peuvent être des chaînes ou des nombres. Contrairement aux tableaux indexés de la plupart des langages, les tableaux awk sont en réalité des tables de hachage — parfaites pour regrouper et agréger les données selon les valeurs des champs.

• Déclaration implicite : il suffit d’affecter une valeur à arr[key] = value
• Les clés sont des chaînes par défaut (les nombres sont convertis)
• Aucune limite de taille — awk agrandit le tableau selon les besoins
• Idéal pour calculer des sommes, des comptes et des regroupements en une seule passe

Il n’est pas nécessaire d’initialiser une clé avant de l’incrémenter — awk traite automatiquement une clé non définie comme zéro ou comme une chaîne vide.

Le schéma d’agrégation le plus courant consiste à compter combien de fois chaque valeur unique d’un champ apparaît. Utilisez le champ $1 (ou n’importe quel autre champ) comme clé du tableau et incrémentez un compteur à chaque ligne correspondante.

Le bloc END s’exécute une fois toutes les données d’entrée consommées — c’est à cet endroit que vous affichez les résultats accumulés.

count[$1]++

Après le traitement, count contient le nombre total de lignes pour chaque valeur unique de $1.

Le comptage n’est qu’une forme d’agrégation. Pour calculer la somme d’un champ numérique regroupé selon un autre champ, accumulez la valeur numérique dans un tableau dont la clé est le champ de regroupement.

Le schéma est le suivant :

• Clé = le champ de regroupement (par exemple, $1 pour le nom d’utilisateur)
• Valeur = le total cumulé du champ numérique (par exemple, $2 pour le nombre d’octets)

Cette méthode calcule une somme complète par groupe en une seule passe awk — aucun tri ni prétraitement n’est nécessaire.

awk vous permet de gérer plusieurs tableaux simultanément, ce qui vous donne le compte et la somme (et donc la moyenne) pour chaque groupe en un seul parcours du fichier. C’est bien plus efficace que d’exécuter la chaîne de traitement deux fois.

• count[key]++ — suit le nombre d’occurrences
• total[key] += $N — suit la somme cumulée
• Dans END, divisez total[k] / count[k] pour obtenir la moyenne par groupe

Vous pouvez créer une clé composite en concaténant plusieurs champs avec un séparateur. Vous obtenez ainsi un regroupement en deux dimensions sans syntaxe particulière.

Choisissez un séparateur qui ne peut pas apparaître dans les données (par exemple, SUBSEP, le séparateur d’enregistrements awk intégré \034, ou une barre verticale littérale |).

• Clé composite : arr[$1 SUBSEP $2] ou arr[$1"|"$2]
• Reconstituer la clé lors de l’affichage : split(key, parts, "|")

Les tableaux associatifs facilitent le suivi des valeurs min et max par groupe. L’astuce consiste à initialiser uniquement lors de la première occurrence de chaque clé grâce à la condition spéciale !(key in arr).

• !(key in min_arr) est vraie la première fois qu’une clé est rencontrée
• Après l’initialisation, comparez puis remplacez avec la comparaison standard inférieur à / supérieur à

Ce schéma évite qu’un zéro parasite ne fausse votre minimum.

Une tâche courante dans les situations réelles consiste à trouver les valeurs les plus fréquentes, au nombre de N. awk s’occupe du comptage ; utilisez sort puis head pour classer et limiter les résultats.

Ce schéma de chaîne de traitement est caractéristique de l’ingénierie des scripts shell :

1. awk compte les occurrences dans un tableau et affiche count key dans END
2. sort -rn effectue un tri numérique décroissant
3. head -n 5 ne conserve que les 5 premiers résultats

En laissant awk se concentrer sur l’agrégation et en déléguant le tri à sort, vous suivez la philosophie Unix.

Lors du traitement de plusieurs fichiers, les variables intégrées NR (nombre total d’enregistrements lus) et FNR (nombre d’enregistrements dans le fichier actuel) vous permettent d’indiquer de quel fichier provient chaque enregistrement à l’aide de FILENAME.

• FILENAME — nom du fichier en cours de lecture
• FNR == 1 — se déclenche au début de chaque nouveau fichier (utile pour ignorer les en-têtes)

Cela permet d’effectuer une agrégation par fichier sur l’ensemble d’un répertoire de journaux en une seule invocation d’awk.

La boucle for (key in array) d’awk ne garantit pas l’ordre. Pour obtenir une sortie déterministe, envoyez l’affichage du bloc END d’awk vers sort, ou rassemblez les valeurs et triez-les dans awk à l’aide des fonctions asorti / asort (GNU awk uniquement).

L’approche portable avec une chaîne de traitement shell est généralement privilégiée pour les scripts multiplateformes :

• sort -k1,1 — trie alphabétiquement selon le premier champ (la clé du groupe)
• sort -k2,2rn — trie numériquement par ordre décroissant selon le deuxième champ (le compte ou la somme)

Vous devez parfois réinitialiser l’état de l’agrégation au milieu du flux — par exemple, lors du traitement de fichiers journaux où chaque section est séparée par une ligne vide ou une valeur sentinelle.

• delete arr[key] — supprime une seule entrée
• delete arr — efface le tableau entier (GNU awk)
• Vérifiez l’existence avec (key in arr) avant d’y accéder afin d’éviter de créer des entrées fantômes

Cette technique permet d’effectuer une agrégation par fenêtre glissante ou par section sans redémarrer awk.

Mettons tout cela en pratique : voici une agrégation awk de qualité production, effectuée en une seule passe sur un journal Nginx au format combiné. Elle calcule le nombre de requêtes, le nombre total d’octets et le taux d’erreur pour chaque hôte virtuel en un seul parcours.

Techniques clés utilisées :

• Clé composite : vhost extrait d’un champ
• Tableaux parallèles : reqs[], bytes[], errors[]
• Accumulation conditionnelle : $9 >= 400 pour ne compter que les réponses en erreur
• Tableau mis en forme avec printf dans END

Vérifiez votre compréhension d’un piège courant de l’agrégation awk.

Vous avez appris les principaux schémas permettant de calculer des agrégations par groupe entièrement dans awk :

• Comptage : count[$key]++ — incrémenter à chaque ligne, afficher dans END
• Somme : total[$key] += $N — accumuler les champs numériques par groupe
• Moyenne : conserver à la fois count[] et total[], puis diviser dans END
• Minimum/maximum : initialiser à la première occurrence avec !(key in arr), puis comparer
• Clés composites : concaténer les champs avec un séparateur pour effectuer un regroupement multidimensionnel
• Sortie triée : envoyer l’affichage du bloc END d’awk vers sort pour obtenir un ordre déterministe
• Réinitialisation des sections : utiliser delete arr pour effacer l’état entre les sections logiques de l’entrée

Ces schémas vous permettent de remplacer de lourdes requêtes de base de données ou plusieurs passages dans une chaîne de traitement par une seule invocation awk efficace — une compétence essentielle pour l’ingénierie des scripts shell en production.