awk débutant : colonnes, filtres et résumés texte

awk est un outil de la ligne de commande très pratique pour traiter des fichiers texte structurés en colonnes. Il est présent sur la plupart des systèmes Linux et permet, avec des commandes courtes, d’extraire des champs, de filtrer des lignes selon des règles simples, puis de produire des résumés comme un total, un comptage ou une moyenne.

Ce tutoriel s’adresse à un public débutant. L’objectif n’est pas de couvrir tout le langage awk, mais de construire des bases solides et immédiatement utiles sur des cas fréquents : afficher certaines colonnes, choisir seulement les lignes qui vous intéressent, et calculer des valeurs de synthèse à partir d’un fichier texte.

Les exemples utilisent des commandes exécutées dans un terminal Linux. Pour rester clair, nous partirons de petits fichiers de démonstration créés localement, puis nous montrerons comment adapter les mêmes idées à d’autres fichiers délimités par des espaces ou par des deux-points. Vous verrez aussi les variables intégrées les plus utiles, les erreurs classiques chez les débutants et quelques bonnes habitudes pour écrire des commandes plus lisibles.

Prérequis

Savoir ouvrir un terminal Linux.
Connaître les commandes de base comme cat, printf, pwd et ls.
Comprendre qu’un fichier texte peut être organisé en lignes et en colonnes.
Avoir le droit de créer des fichiers dans votre répertoire de travail.

Matériel nécessaire

Un système Linux avec un terminal
La commande awk disponible dans le shell
Un répertoire de travail pour créer des fichiers d’exemple

Étapes

1
Comprendre le rôle de awk

awk lit un fichier texte ligne par ligne. Pour chaque ligne, il découpe le contenu en champs selon un séparateur, puis applique les instructions que vous lui donnez. Dans les cas simples, ce séparateur est l’espace blanc, ce qui permet de travailler facilement sur des fichiers organisés en colonnes.
La forme la plus classique d’une commande awk ressemble à ceci :
bash
```
awk 'condition { action }' fichier.txt
```
Cette structure contient deux idées importantes :
- la condition décide si une ligne doit être traitée ;
- l’action décrit ce qu’il faut faire avec la ligne retenue.
Quand vous débutez, retenez déjà trois comportements simples :
- si vous écrivez seulement une action, awk l’applique à chaque ligne ;
- si vous écrivez seulement une condition, awk affiche par défaut les lignes qui correspondent ;
- les champs d’une ligne sont accessibles avec $1, $2, $3, etc.
Par exemple, pour afficher la première colonne d’un fichier :
bash
```
awk '{ print $1 }' fichier.txt
```
Ici, print demande l’affichage, et $1 représente le premier champ de la ligne en cours.
awk fournit aussi quelques variables intégrées très utiles :
- NR : numéro de la ligne courante dans l’ensemble du traitement ;
- NF : nombre de champs dans la ligne courante ;
- $0 : ligne complète telle qu’awk la voit.
Vous n’avez pas besoin de tout mémoriser immédiatement. Le plus important pour commencer est d’associer awk à ce modèle mental : lire une ligne, la découper, puis afficher ou calculer quelque chose à partir de ses champs.
2
Créer un fichier d’exemple simple

Pour apprendre sereinement, il est utile de travailler sur un petit fichier dont vous connaissez exactement le contenu. Dans un répertoire de test, créez un fichier nommé ventes.txt avec plusieurs colonnes : un produit, une catégorie, une quantité et un prix.
bash
```
printf 'pommes fruit 12 2.50\npoires fruit 8 3.10\ncarottes legume 15 1.80\npommes fruit 5 2.60\npoireaux legume 7 2.20\n' > ventes.txt
```
Vous pouvez vérifier son contenu avec :
bash
```
cat ventes.txt
```
Vous devriez voir cinq lignes, chacune composée de quatre champs séparés par des espaces. Cela suffit pour découvrir la plupart des usages de base.
Dans ce fichier :
- $1 correspond au nom du produit ;
- $2 correspond à la catégorie ;
- $3 correspond à la quantité ;
- $4 correspond au prix.
Cette préparation est importante, car awk fonctionne d’autant mieux que la structure du fichier est claire. Si les colonnes sont régulières et le séparateur cohérent, les commandes restent courtes et lisibles.
À partir de maintenant, toutes les premières manipulations se feront sur ce fichier. Vous pourrez ensuite remplacer ventes.txt par vos propres données.
3
Afficher une ou plusieurs colonnes

L’usage le plus direct de awk consiste à extraire certaines colonnes d’un fichier. Supposons que vous souhaitiez afficher uniquement les noms de produits :
bash
```
awk '{ print $1 }' ventes.txt
```
Pour afficher le produit et la quantité :
bash
```
awk '{ print $1, $3 }' ventes.txt
```
Lorsque plusieurs expressions sont séparées par des virgules dans print, awk les affiche avec un séparateur de sortie standard entre elles. Pour un débutant, cela suffit largement dans la plupart des cas.
Vous pouvez aussi réorganiser les colonnes. Par exemple, quantité puis produit :
bash
```
awk '{ print $3, $1 }' ventes.txt
```
Il est également possible d’ajouter un texte explicatif :
bash
```
awk '{ print "produit:", $1, "quantite:", $3 }' ventes.txt
```
Pour afficher la ligne complète précédée de son numéro :
bash
```
awk '{ print NR, $0 }' ventes.txt
```
La variable NR est très utile pour repérer rapidement une ligne dans un fichier. Quant à $0, elle permet de conserver la ligne entière sans avoir à réassembler ses champs.
Enfin, si vous ne savez pas combien de colonnes possède votre fichier, affichez le nombre de champs par ligne :
bash
```
awk '{ print NR, NF, $0 }' ventes.txt
```
Cette commande aide à détecter les lignes qui n’ont pas la même structure que les autres. Si une ligne a un nombre de champs inattendu, vous le verrez immédiatement.
4
Filtrer des lignes avec une condition simple

awk devient particulièrement intéressant lorsqu’on ajoute une condition. Si vous voulez afficher seulement les lignes dont la catégorie est fruit, vous pouvez écrire :
bash
```
awk '$2 == "fruit" { print $0 }' ventes.txt
```
La condition $2 == "fruit" signifie : traiter uniquement les lignes dont le deuxième champ vaut exactement fruit.
Comme l’action par défaut d’une condition vraie est l’affichage de la ligne, on peut aussi écrire plus court :
bash
```
awk '$2 == "fruit"' ventes.txt
```
Les deux commandes sont pratiques. La première est souvent plus pédagogique au début, car elle rend explicite l’action réalisée.
Voici d’autres exemples simples :
- afficher les lignes où la quantité vaut 10 ou plus :
bash
```
awk '$3 >= 10' ventes.txt
```
- afficher les lignes où le produit est pommes :
bash
```
awk '$1 == "pommes"' ventes.txt
```
- afficher les lignes où la catégorie n’est pas fruit :
bash
```
awk '$2 != "fruit"' ventes.txt
```
Vous pouvez ensuite combiner condition et sélection de colonnes. Par exemple, afficher seulement le produit et le prix pour les fruits :
bash
```
awk '$2 == "fruit" { print $1, $4 }' ventes.txt
```
C’est un modèle fondamental : choisir les lignes avec une condition, puis afficher exactement les colonnes utiles.
5
Combiner plusieurs conditions

Dans des fichiers réels, un seul test ne suffit pas toujours. awk permet de combiner des conditions avec des opérateurs logiques simples.
Pour afficher les fruits dont la quantité est au moins égale à 10 :
bash
```
awk '$2 == "fruit" && $3 >= 10' ventes.txt
```
Ici, && signifie et. Les deux conditions doivent être vraies.
Pour afficher les lignes dont la catégorie est fruit ou legume :
bash
```
awk '$2 == "fruit" || $2 == "legume"' ventes.txt
```
Ici, || signifie ou.
Vous pouvez aussi utiliser des parenthèses pour rendre une expression plus lisible :
bash
```
awk '($2 == "fruit") && ($4 > 2.55)' ventes.txt
```
Cette commande retient les lignes dont la catégorie est fruit et dont le prix est supérieur à 2.55.
Quand vous débutez, gardez deux bonnes habitudes :
- commencez par tester une condition simple ;
- ajoutez ensuite les autres conditions une par une.
Cela évite de construire d’un seul coup une commande difficile à déboguer. Si le résultat n’est pas celui attendu, vous pourrez plus facilement identifier la partie problématique.
6
Utiliser BEGIN et END pour préparer ou résumer

awk peut exécuter des blocs spéciaux avant et après la lecture des lignes. Les plus connus sont BEGIN et END.
- BEGIN s’exécute avant la lecture du fichier.
- END s’exécute après la dernière ligne.
Ils sont très utiles pour afficher un en-tête ou un résumé final. Exemple :
bash
```
awk 'BEGIN { print "Produits et quantites" } { print $1, $3 }' ventes.txt
```
Le bloc BEGIN affiche ici une ligne de titre avant le traitement du fichier.
Pour compter le nombre total de lignes :
bash
```
awk 'END { print NR }' ventes.txt
```
Comme NR contient le numéro de la ligne courante, sa valeur finale correspond au nombre de lignes lues.
Vous pouvez combiner BEGIN, traitement principal et END dans une même commande :
bash
```
awk 'BEGIN { print "Resume" } { print $1, $3 } END { print "Lignes:", NR }' ventes.txt
```
Cette organisation est très utile quand une commande devient plus riche. Elle clarifie le rôle de chaque partie : préparation, traitement ligne par ligne, puis synthèse finale.
7
Calculer des totaux, des comptes et des moyennes

L’un des grands intérêts de awk est de pouvoir accumuler des valeurs pendant la lecture du fichier. Pour calculer la somme des quantités de la troisième colonne :
bash
```
awk '{ total += $3 } END { print total }' ventes.txt
```
La variable total est incrémentée à chaque ligne. À la fin, le bloc END affiche le résultat.
Pour compter uniquement les lignes de la catégorie fruit :
bash
```
awk '$2 == "fruit" { count += 1 } END { print count }' ventes.txt
```
Vous pouvez aussi écrire un incrément plus compact :
bash
```
awk '$2 == "fruit" { count++ } END { print count }' ventes.txt
```
Pour calculer la moyenne des quantités :
bash
```
awk '{ total += $3; count++ } END { print total / count }' ventes.txt
```
Cette commande additionne toutes les quantités puis divise la somme par le nombre de lignes.
Pour éviter une division sans ligne traitée, vous pouvez ajouter un test simple :
bash
```
awk '{ total += $3; count++ } END { if (count > 0) print total / count }' ventes.txt
```
Un autre exemple courant consiste à calculer un montant ligne par ligne, puis à l’additionner. Si l’on considère que le montant vaut quantité × prix, on peut écrire :
bash
```
awk '{ total += $3 * $4 } END { print total }' ventes.txt
```
Ce schéma est essentiel : lire, accumuler dans une variable, afficher à la fin. Une grande partie des résumés simples avec awk repose sur cette logique.
8
Produire un résumé filtré

Les calculs deviennent encore plus utiles quand ils sont associés à un filtre. Par exemple, pour totaliser les quantités uniquement pour les fruits :
bash
```
awk '$2 == "fruit" { total += $3 } END { print total }' ventes.txt
```
Pour calculer la moyenne du prix des fruits :
bash
```
awk '$2 == "fruit" { total += $4; count++ } END { if (count > 0) print total / count }' ventes.txt
```
Pour compter combien de lignes ont un prix supérieur à 2.50 :
bash
```
awk '$4 > 2.50 { count++ } END { print count }' ventes.txt
```
Vous pouvez aussi construire un petit rapport lisible :
bash
```
awk 'BEGIN { print "Resume fruits" } $2 == "fruit" { total += $3; count++ } END { print "lignes:", count; print "quantite totale:", total }' ventes.txt
```
Cette manière de faire est très pratique lorsque vous manipulez des journaux, des exports ou des listes tabulaires dans lesquelles vous ne voulez résumer qu’une partie des données.
9
Changer le séparateur de champs

Jusqu’ici, nous avons travaillé avec des champs séparés par des espaces. Mais beaucoup de fichiers texte utilisent un autre délimiteur, comme le deux-points. awk permet de définir le séparateur avec l’option -F.
Créons un second fichier d’exemple :
bash
```
printf 'alice:admin:1001\nbob:user:1002\nclaire:user:1003\n' > comptes.txt
```
Affichez son contenu :
bash
```
cat comptes.txt
```
Ici, les champs sont séparés par :. Pour afficher le nom et le rôle :
bash
```
awk -F ':' '{ print $1, $2 }' comptes.txt
```
Pour n’afficher que les comptes dont le rôle est user :
bash
```
awk -F ':' '$2 == "user" { print $1 }' comptes.txt
```
Pour compter les lignes :
bash
```
awk -F ':' 'END { print NR }' comptes.txt
```
Le principe reste le même que précédemment : seul le séparateur de champs change. Dès que vous voyez un fichier délimité par un caractère stable, pensez à -F.
Une précaution utile : si un fichier contient des espaces dans les valeurs, il faut bien identifier le vrai séparateur avant d’écrire la commande. Beaucoup d’erreurs viennent d’un mauvais choix de séparateur plutôt que d’un problème de syntaxe awk.
10
Ignorer une ligne d’en-tête

De nombreux fichiers commencent par une ligne d’en-tête. Supposons un fichier où la première ligne décrit les colonnes. Vous pouvez le créer ainsi :
bash
```
printf 'produit categorie quantite prix\npommes fruit 12 2.50\npoires fruit 8 3.10\ncarottes legume 15 1.80\n' > ventes_avec_entete.txt
```
Si vous voulez ignorer cette première ligne, utilisez NR > 1 :
bash
```
awk 'NR > 1 { print $1, $3 }' ventes_avec_entete.txt
```
Pour calculer un total sans tenir compte de l’en-tête :
bash
```
awk 'NR > 1 { total += $3 } END { print total }' ventes_avec_entete.txt
```
Vous pouvez aussi afficher l’en-tête différemment :
bash
```
awk 'NR == 1 { print "Colonnes:", $0 } NR > 1 { print $1, $3 }' ventes_avec_entete.txt
```
C’est une technique très fréquente dans les exports texte, notamment lorsqu’un fichier mélange une première ligne descriptive et des lignes de données régulières.
11
Mettre en forme la sortie pour qu’elle soit lisible

Une commande awk n’est pas seulement utile pour filtrer : elle peut aussi produire une sortie plus lisible. Même sans entrer dans des formats complexes, quelques pratiques simples rendent les résultats plus clairs.
Par exemple, ajouter des libellés :
bash
```
awk '{ print "produit=", $1, "prix=", $4 }' ventes.txt
```
Ajouter le numéro de ligne :
bash
```
awk '{ print "ligne", NR, ":", $1, $2, $3, $4 }' ventes.txt
```
Créer un petit résumé final lisible :
bash
```
awk 'BEGIN { print "--- rapport ---" } { total += $3; count++ } END { print "lignes:", count; print "total quantite:", total }' ventes.txt
```
Vous pouvez également ne garder que certains champs mais dans un ordre plus parlant pour l’humain :
bash
```
awk '{ print $1, "->", $2, "->", $3, "->", $4 }' ventes.txt
```
Quand vous partagez une commande avec d’autres personnes, la lisibilité du résultat compte presque autant que le calcul lui-même. Une sortie bien structurée aide à vérifier rapidement que le traitement correspond à l’intention.
12
Utiliser awk avec un tube depuis une autre commande

awk s’emploie très souvent à la fin d’un tube, c’est-à-dire après une autre commande qui produit du texte. Le principe reste identique : awk lit ce texte ligne par ligne depuis l’entrée standard.
Exemple simple avec cat :
bash
```
cat ventes.txt | awk '{ print $1, $3 }'
```
Dans la pratique, il est souvent plus direct de donner le fichier à awk sans passer par cat :
bash
```
awk '{ print $1, $3 }' ventes.txt
```
En revanche, le tube est utile lorsque la source n’est pas un fichier simple. Par exemple, si une commande génère plusieurs lignes de texte, awk peut en extraire certaines colonnes ou en résumer une partie.
Voici un exemple avec printf :
bash
```
printf 'a 1\nb 2\nc 3\n' | awk '{ total += $2 } END { print total }'
```
Ce mode de fonctionnement fait de awk un excellent maillon dans une chaîne d’outils Unix : une commande produit du texte, awk le trie, le réduit ou le résume, puis le résultat peut être envoyé ailleurs.
13
Écrire des commandes awk progressivement

Quand une commande devient un peu longue, la meilleure méthode consiste à la construire par étapes. Prenons un objectif concret : afficher les fruits, montrer produit et quantité, puis calculer la quantité totale.
Étape 1 : vérifier la structure du fichier.
bash
```
awk '{ print NR, NF, $0 }' ventes.txt
```
Étape 2 : filtrer les fruits.
bash
```
awk '$2 == "fruit"' ventes.txt
```
Étape 3 : n’afficher que les colonnes utiles.
bash
```
awk '$2 == "fruit" { print $1, $3 }' ventes.txt
```
Étape 4 : ajouter une accumulation.
bash
```
awk '$2 == "fruit" { print $1, $3; total += $3 } END { print "total:", total }' ventes.txt
```
Cette manière de procéder est très efficace pour les débutants. Chaque étape a un résultat observable. Si quelque chose ne marche pas, vous savez à quel moment l’erreur apparaît.
De plus, cette approche vous aide à mieux comprendre la logique d’awk : d’abord inspecter, ensuite filtrer, puis afficher, enfin résumer.
14
Cas pratiques récapitulatifs

Voici une série de petits cas pratiques reprenant les notions essentielles du tutoriel.
Afficher la première et la quatrième colonne :
bash
```
awk '{ print $1, $4 }' ventes.txt
```
Afficher seulement les légumes :
bash
```
awk '$2 == "legume"' ventes.txt
```
Afficher les produits dont la quantité dépasse 10 :
bash
```
awk '$3 > 10 { print $1, $3 }' ventes.txt
```
Compter les lignes du fichier :
bash
```
awk 'END { print NR }' ventes.txt
```
Totaliser les quantités :
bash
```
awk '{ total += $3 } END { print total }' ventes.txt
```
Calculer la moyenne de la quatrième colonne :
bash
```
awk '{ total += $4; count++ } END { if (count > 0) print total / count }' ventes.txt
```
Lire un fichier séparé par des deux-points :
bash
```
awk -F ':' '{ print $1, $2 }' comptes.txt
```
Ignorer la première ligne d’un fichier avec en-tête :
bash
```
awk 'NR > 1 { print $1, $3 }' ventes_avec_entete.txt
```
Si vous maîtrisez ces modèles, vous avez déjà une base solide pour de nombreux traitements de texte en ligne de commande.

Erreurs fréquentes & dépannage

1. Se tromper de séparateur de champs

Si les résultats semblent décalés ou vides, le problème vient souvent du séparateur. Un fichier séparé par : doit être lu avec -F ':'. Si vous laissez le séparateur par défaut, $1, $2 et les autres champs ne correspondront pas à ce que vous attendez.

2. Oublier les guillemets du programme awk

En shell, le programme awk doit généralement être placé entre quotes simples :

bash

awk '{ print $1 }' ventes.txt

Sans cela, le shell peut interpréter une partie de la commande avant awk.

3. Confondre chaîne de caractères et test numérique

Pour un texte, on écrit par exemple $2 == "fruit". Pour une comparaison numérique, on écrit par exemple $3 > 10. Mélanger les deux rend parfois les résultats difficiles à comprendre.

4. Oublier que la première ligne est un en-tête

Si un total ou une moyenne semble incohérent, vérifiez qu’une ligne descriptive n’est pas incluse dans le calcul. Dans ce cas, utilisez NR > 1.

5. Supposer que toutes les lignes ont la même structure

Un fichier réel peut contenir des lignes incomplètes. Avant un calcul, il peut être utile d’inspecter le nombre de champs avec NF :

bash

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

6. Construire une commande trop complexe d’un seul coup

Il vaut mieux partir d’une commande minimale, vérifier la sortie, puis ajouter le filtre, ensuite l’affichage des colonnes, puis enfin le résumé.

Astuces & pour aller plus loin

Commencez toujours par observer le fichier

Avant de filtrer ou de calculer, affichez quelques lignes et vérifiez la structure logique des colonnes. Une commande comme awk '{ print NR, NF, $0 }' fichier.txt donne très vite une vue utile du contenu.

Nommer les variables simplement

Pour les totaux et les compteurs, utilisez des noms évidents comme total et count. Cela rend la commande plus compréhensible, même après plusieurs jours.

Séparer filtrage et résumé dans votre raisonnement

Pensez en deux temps : quelles lignes garder, puis quelle information afficher ou accumuler. Cette méthode évite beaucoup de confusion.

Ajouter un bloc END pour valider le résultat final

Même pour des essais simples, un bloc END est pratique pour afficher un total, un nombre de lignes ou une moyenne à la fin du traitement.

Tester sur un petit fichier d’exemple

Avant de lancer une commande sur un gros fichier, reproduisez le cas sur quelques lignes faciles à vérifier à la main. C’est souvent le moyen le plus rapide de confirmer la logique.

Questions fréquentes

À quoi sert awk par rapport à grep ou cut ?

awk est utile quand vous voulez à la fois lire des colonnes, appliquer des conditions et faire des calculs simples. Là où grep cherche surtout des lignes et où cut extrait des champs selon un séparateur, awk combine filtrage, extraction et résumé dans une seule commande.

Comment afficher toute une ligne avec awk ?

Utilisez $0, qui représente la ligne complète en cours de traitement. Exemple : awk '{ print $0 }' fichier.txt.

Comment connaître le nombre de champs sur une ligne ?

Utilisez la variable intégrée NF. Par exemple, awk '{ print NR, NF, $0 }' fichier.txt affiche le numéro de ligne, le nombre de champs et la ligne elle-même.

Comment ignorer la première ligne d’un fichier ?

La forme la plus simple est d’utiliser une condition sur le numéro de ligne : awk 'NR > 1 { print $1 }' fichier.txt. Ainsi, seul le contenu à partir de la deuxième ligne est traité.

Comment changer le séparateur de colonnes ?

Utilisez l’option -F. Par exemple, pour un fichier séparé par des deux-points : awk -F ':' '{ print $1, $2 }' fichier.txt.

Peut-on calculer une somme avec awk ?

Oui. Un modèle classique est awk '{ total += $3 } END { print total }' fichier.txt, qui additionne la troisième colonne puis affiche le total à la fin.

Conclusion

Pour débuter avec awk, il suffit de maîtriser quelques idées clés : les champs $1, $2 et suivants, la ligne complète $0, le numéro de ligne NR, le nombre de champs NF, les conditions simples, puis les accumulations dans des variables pour produire des résumés.

Avec ces bases, vous pouvez déjà résoudre beaucoup de besoins courants sous Linux : extraire des colonnes d’un export texte, filtrer des lignes selon une valeur, compter des occurrences, totaliser des quantités ou calculer une moyenne. La progression la plus sûre consiste à écrire des commandes courtes, à vérifier le séparateur de champs, puis à enrichir progressivement la logique.

Une fois à l’aise sur ces exemples débutants, vous pourrez aller plus loin en explorant des scripts awk plus structurés. Mais pour un grand nombre de tâches quotidiennes en ligne de commande, les modèles vus dans ce tutoriel sont déjà très efficaces.

awk débutant : colonnes, filtres et résumés texte

Prérequis

Matériel nécessaire

Étapes

Comprendre le rôle de awk

Créer un fichier d’exemple simple

Afficher une ou plusieurs colonnes

Filtrer des lignes avec une condition simple

Combiner plusieurs conditions

Utiliser BEGIN et END pour préparer ou résumer

Calculer des totaux, des comptes et des moyennes

Produire un résumé filtré

Changer le séparateur de champs

Ignorer une ligne d’en-tête

Mettre en forme la sortie pour qu’elle soit lisible

Utiliser awk avec un tube depuis une autre commande

Écrire des commandes awk progressivement

Cas pratiques récapitulatifs