Manipuler des fichiers texte avec awk

Mise à jour : 17/04/2025

Au-delà de sed, qui permet de modifier directement le contenu ligne par ligne, il est parfois nécessaire d’extraire des colonnes précises, de transformer des champs, ou de réaliser des calculs à partir de fichiers plats comme des logs, des CSV ou des exports structurés. C’est là que la commande awk devient incontournable. Pensé comme un mini-langage de traitement de texte, awk permet de manipuler chaque ligne comme un enregistrement, et chaque mot comme un champ. Grâce à sa puissance et sa simplicité, il devient un outil indispensable pour analyser, transformer et automatiser le traitement de données textuelles en ligne de commande.

Introduction à `awk`

La commande awk est un outil de traitement de texte conçu pour lire des fichiers ligne par ligne, découper chaque ligne en champs (colonnes), et appliquer des actions conditionnelles sur ces champs. Son nom vient des initiales de ses créateurs : Aho, Weinberger et Kernighan.

Contrairement à grep (filtrage) ou sed (modification ligne à ligne), awk agit comme un mini-langage de programmation. Il permet :

d’extraire des champs spécifiques,
de filtrer des lignes selon des règles complexes,
de réaliser des calculs (sommes, moyennes, comptages),
de reformater ou restructurer des fichiers texte.

Un exemple simple pour afficher les colonnes 1 et 3 d’un fichier séparé par des espaces :

awk '{ print $1, $3 }' fichier.txt

Ou, avec un fichier CSV (séparateur ;) :

awk -F';' '{ print $2 }' fichier.csv

Et pour calculer la somme d’une colonne :

awk '{ total += $3 } END { print total }' fichier.txt

Avec awk, chaque ligne devient un enregistrement à traiter, chaque mot un champ manipulable, et chaque fichier une source de données structurées à analyser ou transformer en temps réel.

Syntaxe de base

La syntaxe de awk repose sur le principe suivant : pour chaque ligne du fichier, si un motif est vrai, alors on exécute une action. Cette syntaxe, très naturelle, permet d’écrire des commandes puissantes en quelques caractères seulement.

Structure générale

awk 'motif { action }' fichier

motif : condition pour exécuter l’action (optionnelle)
action : opération à réaliser sur la ligne (affichage, calcul, etc.)

Si aucun motif n’est précisé, l’action est appliquée à chaque ligne.

Variables implicites

awk propose plusieurs variables intégrées très utiles :

$0 : la ligne entière
$1, $2, … : les champs de la ligne (colonne 1, 2, etc.)
NF : nombre de champs dans la ligne
NR : numéro de la ligne en cours
FS : séparateur de champs (par défaut, espace ou tabulation)

Exemples simples

Afficher toutes les lignes d’un fichier :

awk '{ print }' fichier.txt

Afficher la 2ᵉ colonne uniquement :

awk '{ print $2 }' fichier.txt

Afficher la dernière colonne :

awk '{ print $NF }' fichier.txt

Changer le séparateur de champs (ex : fichier CSV) :

awk -F';' '{ print $1, $3 }' fichier.csv

Afficher le numéro de ligne suivi du contenu :

awk '{ print NR, $0 }' fichier.txt

Grâce à cette syntaxe, awk devient rapidement un outil de transformation, de lecture et d’analyse de données, tout en restant compact et intuitif.

Extraction et filtrage de données

L’un des usages les plus courants de awk est d’extraire des colonnes spécifiques d’un fichier texte et de filtrer les lignes selon des critères simples ou complexes. Cela permet de parcourir rapidement un fichier structuré et d’en isoler les informations utiles.

Afficher une ou plusieurs colonnes

Afficher la première colonne :

awk '{ print $1 }' fichier.txt

Afficher les colonnes 1 et 3 :

awk '{ print $1, $3 }' fichier.txt

Afficher la dernière colonne :

awk '{ print $NF }' fichier.txt

Filtrer une ligne selon une valeur

Afficher les lignes dont la 3e colonne vaut exactement “OK” :

awk '$3 == "OK"' fichier.txt

Afficher celles dont la 2e colonne est supérieure à 100 :

awk '$2 > 100' fichier.txt

Utiliser une condition ET/OU

Afficher les lignes où la colonne 2 est > 100 et la colonne 4 contient “valide” :

awk '$2 > 100 && $4 == "valide"' fichier.txt

Afficher les lignes où la colonne 1 est “admin” ou “root” :

awk '$1 == "admin" || $1 == "root"' fichier.txt

Filtrer avec une expression régulière

Afficher les lignes dont la colonne 1 commence par “user” :

awk '$1 ~ /^user/' fichier.txt

Afficher celles où la colonne 3 ne contient pas “erreur” :

awk '$3 !~ /erreur/' fichier.txt

Afficher les lignes entre deux motifs

Afficher de la ligne contenant “START” à celle contenant “END” :

awk '/START/,/END/' fichier.txt

Grâce à ces fonctionnalités, awk permet de naviguer, trier, extraire ou surveiller des données textuelles structurées avec une très grande souplesse.

Calculs et agrégations

awk est particulièrement efficace pour effectuer des opérations mathématiques sur les données textuelles : sommes, moyennes, minima, maxima, et même des calculs conditionnels. Ces fonctionnalités permettent d’analyser rapidement le contenu d’un fichier numérique.

Somme d’une colonne

Additionner toutes les valeurs de la colonne 2 :

awk '{ total += $2 } END { print total }' fichier.txt

Moyenne d’une colonne

Calculer la moyenne des valeurs numériques d’une colonne :

awk '{ total += $3; n++ } END { print total / n }' fichier.txt

Trouver un minimum ou un maximum

Trouver la valeur maximale de la colonne 4 :

awk 'NR == 1 || $4 > max { max = $4 } END { print max }' fichier.txt

Trouver la valeur minimale :

awk 'NR == 1 || $4 < min { min = $4 } END { print min }' fichier.txt

Comptage de lignes selon une condition

Compter les lignes dont la colonne 3 vaut “OK” :

awk '$3 == "OK" { count++ } END { print count }' fichier.txt

Moyenne conditionnelle

Moyenne des lignes où le champ 2 est supérieur à 50 :

awk '$2 > 50 { total += $2; n++ } END { if (n > 0) print total / n }' fichier.txt

Calculs entre colonnes

Calculer la différence entre deux colonnes et afficher la ligne :

awk '{ diff = $3 - $2; print $1, diff }' fichier.txt

Avec ces opérations, awk devient un véritable moteur d’analyse statistique en ligne de commande, idéal pour examiner des rapports, des mesures systèmes ou des exports CSV chiffrés.

Formatage de la sortie

awk permet de personnaliser l’affichage des résultats avec une grande finesse grâce à la commande printf, qui offre un meilleur contrôle que print sur l’alignement, le format numérique ou la structure des données affichées.

Différence entre `print` et `printf`

print ajoute automatiquement un espace entre les champs et un retour à la ligne
printf permet de formater précisément la sortie, mais ne gère ni espaces ni retours à la ligne automatiquement

Syntaxe de base de `printf`

awk '{ printf "%s : %s\n", $1, $2 }' fichier.txt

%s : chaîne de caractères
%d : entier
%f : nombre à virgule flottante
\n : retour à la ligne

Alignement des colonnes

Aligner à gauche (%-) ou à droite (%) avec une largeur fixe :

awk '{ printf "%-10s | %5d\n", $1, $2 }' fichier.txt

Affiche la première colonne sur 10 caractères à gauche et la seconde sur 5 caractères à droite.

Afficher des nombres avec précision

Limiter à 2 décimales :

awk '{ printf "%.2f\n", $2 }' fichier.txt

Ajout de titres et de séparateurs

Afficher une entête et un tableau structuré :

awk 'BEGIN { printf "%-10s | %s\n", "Nom", "Valeur"; print "--------------------" }
     { printf "%-10s | %s\n", $1, $2 }' fichier.txt

Avec BEGIN, on peut afficher des lignes avant le traitement du fichier.

En combinant printf et les variables d’awk, on peut produire des rapports lisibles, alignés, prêts à être copiés ou intégrés dans un fichier HTML, CSV ou Markdown, ce qui rend l’outil encore plus précieux pour l’analyse.

Expressions régulières

Comme grep ou sed, awk prend en charge les expressions régulières pour filtrer ou analyser les lignes de manière avancée. On les utilise généralement avec les opérateurs ~ (correspondance) ou !~ (non-correspondance).

Correspondance avec `~`

Afficher les lignes dont la première colonne commence par “admin” :

awk '$1 ~ /^admin/' fichier.txt

Afficher les lignes dont la troisième colonne contient “OK” :

awk '$3 ~ /OK/' fichier.txt

Négation avec `!~`

Afficher les lignes qui ne contiennent pas “erreur” dans la colonne 4 :

awk '$4 !~ /erreur/' fichier.txt

Classes de caractères

Afficher les lignes dont la colonne 2 contient un chiffre :

awk '$2 ~ /[0-9]/' fichier.txt

Afficher les lignes où la première colonne est une adresse IP :

awk '$1 ~ /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/' fichier.txt

Motifs combinés avec `&&` ou `||`

Afficher les lignes dont la colonne 2 contient “start” et la colonne 3 “ok” :

awk '$2 ~ /start/ && $3 ~ /ok/' fichier.txt

Expressions régulières dans un `BEGIN` ou `END`

On peut aussi préparer un motif à l’avance :

awk 'BEGIN { motif="^[A-Z]+" } $1 ~ motif' fichier.txt

Grâce à ces expressions régulières, awk peut filtrer des motifs complexes, gérer des formats variables, et se montrer extrêmement puissant pour analyser des fichiers non structurés ou semi-structurés.

Fonctions et variables personnalisées

awk est un vrai mini-langage de programmation, ce qui signifie qu’on peut déclarer ses propres variables et fonctions pour rendre les traitements plus lisibles, réutilisables ou structurés. Cela permet de transformer des expressions complexes en blocs simples et maintenables.

Déclaration de variables

Les variables peuvent être utilisées et modifiées librement :

awk '{ total += $2 } END { print "Total :", total }' fichier.txt

On peut aussi déclarer des variables dans un bloc BEGIN :

awk 'BEGIN { taux = 0.2 } { print $1, $2 * taux }' fichier.txt

Définir une fonction

Une fonction awk est définie avec la syntaxe :

function nom_fonction(arg1, arg2) {
    return arg1 + arg2
}

Exemple : fonction de calcul de TVA

awk '
function tva(prix, taux) {
    return prix * taux
}
{ print $1, tva($2, 0.2) }
' fichier.txt

Réutilisation dans un bloc `END`

On peut appeler des fonctions dans le traitement final :

awk '
function moyenne(total, n) {
    return n > 0 ? total / n : 0
}
{ somme += $2; n++ }
END { print "Moyenne :", moyenne(somme, n) }
' fichier.txt

Portée des variables

Les variables déclarées en dehors d’une fonction sont globales. Celles passées dans une fonction sont locales, sauf si on les modifie directement dans le corps du programme.

Les fonctions personnalisées rendent awk encore plus puissant pour les traitements complexes, notamment dans les scripts longue durée, les fichiers multi-colonnes, ou les opérations conditionnelles répétitives.

Tableaux associatifs

L’un des atouts les plus puissants de awk est sa prise en charge des tableaux associatifs (aussi appelés “dictionnaires”). Contrairement aux tableaux classiques, ils utilisent des chaînes de caractères comme clés, ce qui les rend parfaits pour regrouper ou compter des données par catégorie.

Compter les occurrences d’un champ

Par exemple, pour compter le nombre de lignes par utilisateur (colonne 1) :

awk '{ utilisateurs[$1]++ } END { for (u in utilisateurs) print u, utilisateurs[u] }' fichier.txt

Additionner par groupe

Additionner la colonne 3 pour chaque valeur unique de la colonne 2 :

awk '{ total[$2] += $3 } END { for (groupe in total) print groupe, total[groupe] }' fichier.txt

Tri par catégorie (tri externe avec `sort`)

awk '{ nb[$1]++ } END { for (nom in nb) print nom, nb[nom] }' fichier.txt | sort -k2 -n

Utiliser une clé combinée

On peut combiner plusieurs colonnes comme clé :

awk '{ cle = $1 "-" $2; stats[cle]++ } END { for (c in stats) print c, stats[c] }' fichier.txt

Valeur par défaut et vérification de clé

Tester si une clé existe :

awk '{ if (!($1 in comptage)) comptage[$1] = 0; comptage[$1]++ } END { for (k in comptage) print k, comptage[k] }' fichier.txt

Les tableaux associatifs transforment awk en moteur de regroupement et d’agrégation, très utile pour analyser des logs, faire des statistiques simples ou générer des résumés dynamiques à partir de données brutes.

Écriture de scripts `awk` complets

Lorsque les traitements deviennent complexes, il est plus lisible et plus pratique d’écrire un script awk complet dans un fichier dédié. Cela permet de structurer son code avec des blocs BEGIN, END, des fonctions, et de faciliter la réutilisation dans d’autres contextes.

Structure d’un script `awk`

Un script awk peut comporter trois blocs principaux :

BEGIN {
    # Initialisation
    FS = ";"
    print "Nom | Total"
}

{
    total[$1] += $2
}

END {
    for (nom in total)
        printf "%-10s | %d\n", nom, total[nom]
}

Ce script :

définit le séparateur de champs (FS)
agrège les valeurs numériques par utilisateur
affiche un rapport final formaté

Sauvegarder le script dans un fichier

Enregistrez le code dans un fichier nommé par exemple rapport.awk.

Lancer le script avec `awk -f`

awk -f rapport.awk fichier.csv

Ajouter un shebang pour exécution directe

Débuter le fichier par :

#!/usr/bin/awk -f

Puis rendre le fichier exécutable :

chmod +x rapport.awk
./rapport.awk fichier.csv

Intérêt des scripts `.awk`

Lisibilité et maintenabilité du code
Facilité de test et de versioning (Git, etc.)
Réutilisation dans des pipelines automatisés

Les scripts awk sont idéaux pour les tâches d’analyse régulières, les rapports dynamiques, ou les traitements batch sur de gros volumes de données structurées.

Édition de fichiers plats et CSV

awk est particulièrement adapté à la manipulation de fichiers structurés comme les fichiers CSV, TSV ou les fichiers plats issus de bases de données ou d’exports automatisés. Il permet d’extraire, transformer ou reformater les champs facilement.

Définir un séparateur de champs

Par défaut, awk considère que les champs sont séparés par des espaces ou des tabulations. Pour un fichier CSV avec ; :

awk -F';' '{ print $1, $3 }' fichier.csv

Pour un fichier TSV (tabulations), utilisez :

awk -F'\t' '{ print $2 }' fichier.tsv

Nettoyer une colonne spécifique

Par exemple, supprimer les guillemets dans la colonne 3 :

awk -F';' '{ gsub(/"/, "", $3); print $3 }' fichier.csv

Supprimer une colonne

Supprimer la 2e colonne et réafficher les autres :

awk '{ $2=""; print }' fichier.txt

À noter : cela conserve l’espace entre les colonnes

Convertir un fichier CSV en TSV

awk -F';' 'BEGIN { OFS="\t" } { print $1, $2, $3 }' fichier.csv

Réordonner les colonnes

Afficher la colonne 3, puis la 1, puis la 2 :

awk -F';' '{ print $3, $1, $2 }' fichier.csv

Ajouter une colonne calculée

Par exemple, ajouter un total en additionnant les colonnes 2 et 3 :

awk -F';' 'BEGIN { OFS=";" } { print $0, $2 + $3 }' fichier.csv

awk offre une solution rapide et portable pour préparer des données, nettoyer des exports, ou automatiser la transformation de fichiers structurés sans passer par un tableur ou un script Python complet.

Bonnes pratiques

Pour tirer le meilleur parti de awk dans vos scripts ou en ligne de commande, voici quelques bonnes pratiques qui facilitent la lisibilité, la maintenance et la robustesse de vos traitements.

Toujours définir explicitement le séparateur (`FS`)

Même si l’espace est le séparateur par défaut, mieux vaut le définir clairement, surtout pour les fichiers structurés :

awk 'BEGIN { FS=";" } { print $2 }' fichier.csv

Utiliser `BEGIN` et `END` pour structurer

Utilisez BEGIN pour les initialisations, et END pour les bilans :

awk 'BEGIN { print "Début" } { print $1 } END { print "Fin" }' fichier.txt

Nommer clairement vos variables

Évitez les noms comme a, b, ou x : préférez des noms explicites comme total, compteur, moyenne.

awk '{ total += $2 } END { print "Total :", total }'

Tester vos commandes avec un extrait de fichier

Utilisez head, tail, ou less pour tester vos traitements sur quelques lignes avant de les appliquer à un fichier complet :

head -n 20 fichier.csv | awk -F';' '{ print $1, $2 }'

Utiliser des scripts `.awk` pour les traitements longs

Plutôt que d’écrire des blocs complexes dans une seule ligne :

Créez un fichier script.awk
Ajoutez un shebang (#!/usr/bin/awk -f) si nécessaire
Rappelez-le avec awk -f script.awk fichier.txt

Ajouter des commentaires

Comme dans tout script, commentez les parties clés :

# Calcul du total par produit
{ total[$1] += $3 }

Anticiper les lignes vides ou mal formées

Protégez vos traitements avec des conditions :

awk 'NF > 0 { print $1 }' fichier.txt

En appliquant ces bonnes pratiques, vous ferez de awk un outil fiable et maintenable, aussi puissant dans des scripts d’automatisation que dans une analyse ponctuelle sur un terminal.

Conclusion

La commande awk est bien plus qu’un simple extracteur de colonnes : c’est un langage de traitement de texte structuré, capable d’automatiser l’analyse, la transformation et la présentation de données issues de fichiers plats. Grâce à sa syntaxe concise, sa logique ligne par ligne et ses fonctions avancées comme les tableaux ou les scripts complets, awk devient un allié puissant pour toutes les tâches de manipulation de texte en ligne de commande.