Vous êtes sur la page 1sur 64

C.

Aperghis-Tramoni

Le Langage AWK
C'est un langage de gestion ligne à ligne de fichiers.
Pour être traité par AWK, un fichier données doit, si possible, avoir une
structure cohérente :

<ligne 1> : "Champ 1" "Champ 2" ...... "Champ n"


<ligne 2> : "Champ 1" "Champ 2" ...... "Champ n"
<ligne 3> : "Champ 1" "Champ 2" ...... "Champ n"
.......... .......... .......... ..........
<ligne p> : "Champ 1" "Champ 2" ...... "Champ n"

Il existe des exeptions qui, dépendant de la définition même du type de


données à traiter, ne seront prises en compte que si elles sont parfaitement
connues.

Département d’Informatique 1
Université de la Méditerrannée
C. Aperghis-Tramoni

Fichiers d'exemple.
Les exemples qui seront développés porteront, en
fonction des structures que nous voulons mettre en
évidence, sur les fichier suivants:
Un texte, enregistré sous le nom de sonnet, c'est un
poeme de Ronsard, (Sur la mort de Marie, 1578) dont les
lignes sont, par définition, non structurées (nombre de
champs variable, lignes blanches, ponctuation).
Un fichier parfaitement structuré sur lequel il sera
possible de proceder à des calculs et a des présentations.
Il est stocké sous le nom Chauffeurs.

Département d’Informatique 2
Université de la Méditerrannée
C. Aperghis-Tramoni

Le fichier sonnet.
Terre, ouvre-moi ton sein, et me laisse reprendre
Mon tresor, que ta parque a cache dessous toi;
Ou bien, si tu ne peux, o terre, cache moi
Sous meme sepulture, avec sa belle cendre.

Le trait qui la tua devait faire descendre


Mon corps aupres du sien pour finir mon emoi;
Aussi bien, vu le mal qu’en sa mort je recoit,
Je ne saurais plus vivre, et me fache d’attendre.

Quand ses yeux m’eclairaient, et qu’en terre j’avais


Le bonheur de les voir, a l’heure je vivais,
Ayant de leurs rayons mon ame gouvernee.

Maintenant je suis mort : la Mort qui s’en alla


Loger dedans ses yeux, en parlant m’appela,
Et me fit de ses pieds accomplir ma journee.

Département d’Informatique 3
Université de la Méditerrannée
C. Aperghis-Tramoni

Le fichier Chauffeurs.
Nom Marque de Consomm. Kilomètres Prix du
voiture parcourus litre
de par jour
carb.

Jean Peugeot 10 250 5.50


Claude Citroen 08 350 3.50
Pierre Toyota 14 150 5.00
Robert Peugeot 11 550 5.20
Alain Renault 09 100 5.00
Marc Renault 17 250 5.50
Michel Citroen 10 350 5.20
Norbert Toyota 15 400 5.00
Francois Peugeot 20 350 3.50
Serge Peugeot 11 800 5.90
Luc Toyota 12 750 5.20
Albert Peugeot 07 250 3.50
Charles Renault 12 300 5.50

Département d’Informatique 4
Université de la Méditerrannée
C. Aperghis-Tramoni

Champs et Séparateurs (1).


Le caractère séparant les champs est défini dans une variable globale qui s’appelle FS.

Dans l’exemple qui est décrit le séparateur est l’espace, (FS = “ “).

Le compte des champs d’une ligne courante est calculé il est indiqué par le
positionnement d’une variable globale NF.

Dans notre exemple, le nombre de champs est constant et il est égal à 5, (NF = 5)

Le compte des lignes du fichier d’entrée se trouve dans une variable globale NR.
Notre fichier comporte 12 lignes, (NR = 12).

Tous les types de données


-> étiquettes,
-> fonctions,
-> fichiers,
-> répertoires
ont leur propre zone d’identification.
Département d’Informatique 5
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemples de visualisation (1).


Impression ligne à ligne du fichier. $0 indique la totalité des champs.

/es2i/staff/chris : nawk '{print}'


Chauffeurs
Jean Peugeot 10 250 5.50
Claude Citroen 8 350 3.50
Pierre Toyota 14 150 5.00
Robert Peugeot 11 550 5.20
Alain Renault 9 100 5.00
Marc Renault 17 250 5.50 /es2i/staff/chris : nawk '{print $0}' Chauffeurs
Michel Citroen 10 350 5.20 Jean Peugeot 10 250 5.50
Norbert Toyota 15 400 5.00 Claude Citroen 8 350 3.50
Francois Peugeot 20 350 3.50 Pierre Toyota 14 150 5.00
Serge Peugeot 11 800 5.90 Robert Peugeot 11 550 5.20
Luc Toyota 12 750 5.20 Alain Renault 9 100 5.00
Albert Peugeot 7 250 3.50 Marc Renault 17 250 5.50
Charles Renault 12 300 5.50 Michel Citroen 10 350 5.20
/es2i/staff/chris : Norbert Toyota 15 400 5.00
Francois Peugeot 20 350 3.50
Serge Peugeot 11 800 5.90
Luc Toyota 12 750 5.20
Albert Peugeot 7 250 3.50
Charles Renault 12 300 5.50
/es2i/staff/chris :

Département d’Informatique 6
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemples de visualisation (2).


/es2i/staff/chris : nawk '{print NR,$1,$2,$3,$4,$5}' Chauffeurs
Imprimer chacun des 1 Jean Peugeot 10 250 5.50
champs en les séparant 2 Claude Citroen 8 350 3.50
3 Pierre Toyota 14 150 5.00
par des blancs (virgule) 4 Robert Peugeot 11 550 5.20
5 Alain Renault 9 100 5.00
et en numérotant les 6 Marc Renault 17 250 5.50
lignes (NR). 7 Michel Citroen 10 350 5.20
8 Norbert Toyota 15 400 5.00
9 Francois Peugeot 20 350 3.50
10 Serge Peugeot 11 800 5.90
11 Luc Toyota 12 750 5.20
12 Albert Peugeot 7 250 3.50
13 Charles Renault 12 300 5.50
/es2i/staff/chris :

/es2i/staff/chris : nawk '{print NF,$1,$NF-1}' Chauffeurs


Imprimer pour chaque 5 Jean 4.5
ligne, le nombre de 5 Claude 2.5
5 Pierre 4
champs, le premier puis 5 Robert 4.2
l’avant dernier champ. 5 Alain 4
5 Marc 4.5
5 Michel 4.2
5 Norbert 4
5 Francois 2.5
5 Serge 4.9
5 Luc 4.2
5 Albert 2.5
5 Charles 4.5
/es2i/staff/chris :

Département d’Informatique 7
Université de la Méditerrannée
C. Aperghis-Tramoni

Programmes AWK.
Avant tout, awk (ou nawk) est une commande unix dont elle présente toutes les caractéristiques.
On peut la tuber (ls -al | awk ...),
l’utiliser dans un script etc ...
Awk est aussi un langage de programmation.
Pour des applications simples :
awk 'Programme' Fichier-1 Fichier-2 ..... Fichier-n

Programme est une suite d’instructions dont la forme générale est :


Condition {Instr-1; Instr-2; ...; Instr-n}

La commande exécute le programme fichier par fichier, ligne à ligne, séquenciellement.


Pour une application plus complexe
awk -f Programme [Fichier-1 Fichier-2 ..... Fichier-n]

Programme est dans ces conditions le nom d’un fichier contenant la suite d’instructions.

Si aucun fichier n’est précisé, le fichier d’entrée sera stdin.

Département d’Informatique 8
Université de la Méditerrannée
C. Aperghis-Tramoni

Applications simples.

Trouver tous les possesseurs de Renault.


/es2i/staff/chris : nawk '$2 == "Renault" {print}' Chauffeurs
Alain Renault 9 100 5.00
Marc Renault 17 250 5.50
Charles Renault 12 300 5.50
/es2i/staff/chris : nawk '$2 == "Renault" {print}' Chauffeurs Chauffeurs
Alain Renault 9 100 5.00
Marc Renault 17 250 5.50
Charles Renault 12 300 5.50
Alain Renault 9 100 5.00
Marc Renault 17 250 5.50
Charles Renault 12 300 5.50
/es2i/staff/chris :

Département d’Informatique 9
Université de la Méditerrannée
C. Aperghis-Tramoni

Les fichiers programme.

Pour une application plus complexe, il est préférable que le programme soit
contenu dans un fichier d’instructions. L’exécution du fichier en question
se fera par la commande :

awk -f Programme [Fichier-1 Fichier-2 ... Fichier-n]

Comme précédemment, les instructions contenues dans le fichier seront


exécutées séquentiellementsur les lignes des fichiers donnés en entrée.

De la même manière, si aucun fichier n’est précisé, le fichier d’entrée sera stdin.

Département d’Informatique 10
Université de la Méditerrannée
C. Aperghis-Tramoni

Un fichier programme.
Ecrire un programme (verif) qui vérifie la cohérence
des données du fichier Chauffeurs.
/es2i/staff/chris : cat verif
NF !=5{print $0 "Nombre de champs different de 5"}
$3 > 15 {print $1 " semble consommer beaucoup."}
$4 > 500 {print $1 " roule beaucoup."}
$4 < 200 {print $1 " roule peu."}
$5 > 5.50 {print $1 " paye son essence un peu cher."}
/es2i/staff/chris : nawk -f verif Chauffeurs
Pierre roule peu.
Robert roule beaucoup.
Alain roule peu.
Marc semble consommer beaucoup.
Francois semble consommer beaucoup.
Serge roule beaucoup.
Serge paye son essence un peu cher.
Luc roule beaucoup.
/es2i/staff/chris :

Département d’Informatique 11
Université de la Méditerrannée
C. Aperghis-Tramoni

Le programme AWK.
Un programme awk se présente toujours comme nous venons de le définir :
CONDITION {ACTION}
CONDITION {ACTION}
..........

Une condition porte exclusivement sur une ligne du fichier d’entrée si il en est
précisé un ou sur l’entrée standard (stdin) si aucun fichier n’est indiqué.
Une action ne s’exécutera que si la condition est validée.
Quels sont les noms possesseurs de Toyotas ? awk '$2 == "Toyota" {print $1}' Chauffeurs
Condition Action Fichier

/es2i/staff/chris : nawk '$2 == "Toyota" {print $1}' Chauffeurs


Pierre
Norbert
Luc
/es2i/staff/chris :

Département d’Informatique 12
Université de la Méditerrannée
C. Aperghis-Tramoni

Condition et Action.
La présence des champs condition ou action est facultative.
Si la condition est absente, l’action est exécutée systématiquement.
awk '{print}' Chauffeurs

Si l’action est absente on imprimera la ligne, en fait, l’action standard est {print}
Imprimer les informations relatives aux possesseurs de Peugeots :
awk '$2 == "Peugeot" ' Chauffeurs
ou bien : awk '{if ($2 == "Peugeot") print}' Chauffeurs

/es2i/staff/chris : nawk '$2 == "Peugeot" ' Chauffeurs


Jean Peugeot 10 250 5.50
Robert Peugeot 11 550 5.20
Francois Peugeot 20 350 3.50
Serge Peugeot 11 800 5.90
Albert Peugeot 7 250 3.50
/es2i/staff/chris : nawk '{if ($2 == "Peugeot") print}' Chauffeurs
Jean Peugeot 10 250 5.50
Robert Peugeot 11 550 5.20
Francois Peugeot 20 350 3.50
Serge Peugeot 11 800 5.90
Albert Peugeot 7 250 3.50
/es2i/staff/chris :

Département d’Informatique 13
Université de la Méditerrannée
C. Aperghis-Tramoni

Quelques exemples (1).


Calcul de consommation hebdomadaire.
/es2i/staff/chris : nawk '{print $1,$4*7}' Chauffeurs
Jean 1750
Claude 2450
Pierre 1050
Robert 3850
Alain 700
Marc 1750
Michel 2450
Norbert 2800
Francois 2450
Serge 5600
Luc 5250
Albert 1750
Charles 2100
/es2i/staff/chris :

Département d’Informatique 14
Université de la Méditerrannée
C. Aperghis-Tramoni

les formats.
Il est possiblede formater les données de sortie afin d’obtenir une
présentation agréable : Format
printf (format, valeur-1, valeur-2, ....., valeur-n)
Le format est une chaine contenant entre autre des %
A chaque valeur est associé un %, Il y a autant de % que de valeurs
nawk '{printf ("%s consomme %d litres aux 100, cout hebdomadaire %.2f francs.\n",
$1, $3, $4*7*$5/100)}' Chauffeurs

%s : Format d’une chaine de caractères $1, le nom.


Valeurs
%d : Format d’un nombre entier tel quel $3, la consommation.

%.2f : Format d’un nombre réel présenté avec 2 chiffres aprés la


virgule $4*7*$5/100, le cout hebdomadaire.

\n : Passage à la ligne.

\t : Tabulation.

Département d’Informatique 15
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemple de format.
Calcul de dépense hebdomadaire.
/es2i/staff/chris : nawk '{printf ("%s consomme %d litres aux 100,
cout hebdomadaire %.2f francs.\n", $1, $3, $4*7*$5/100)}' Chauffeurs
Jean consomme 10 litres aux 100, cout hebdomadaire 96.25 francs.
Claude consomme 8 litres aux 100, cout hebdomadaire 85.75 francs.
Pierre consomme 14 litres aux 100, cout hebdomadaire 52.50 francs.
Robert consomme 11 litres aux 100, cout hebdomadaire 200.20 francs.
Alain consomme 9 litres aux 100, cout hebdomadaire 35.00 francs.
Marc consomme 17 litres aux 100, cout hebdomadaire 96.25 francs.
Michel consomme 10 litres aux 100, cout hebdomadaire 127.40 francs.
Norbert consomme 15 litres aux 100, cout hebdomadaire 140.00 francs.
Francois consomme 20 litres aux 100, cout hebdomadaire 85.75 francs.
Serge consomme 11 litres aux 100, cout hebdomadaire 330.40 francs.
Luc consomme 12 litres aux 100, cout hebdomadaire 273.00 francs.
Albert consomme 7 litres aux 100, cout hebdomadaire 61.25 francs.
Charles consomme 12 litres aux 100, cout hebdomadaire 115.50 francs.
/es2i/staff/chris :

Département d’Informatique 16
Université de la Méditerrannée
C. Aperghis-Tramoni

Les entrées sorties.


Détail des fonctions print, printf.

print
Ecriture de *0 sur stdout.

print expression, expression, ...


printf (format,expression, expression, ...)
Ecriture des expressions séparées par OFS et terminées par ORS.

print expression, expression, ... > fichier


printf (format,expression, expression, ...) >fichier
Ecriture dans le fichier des expressions séparées par OFS et terminées par ORS.
print expression, expression, ... >> fichier
printf (format,expression, expression, ...) >> fichier
Ecriture dans le fichier des expressions séparées par OFS et terminées par ORS.
print expression, expression, ... | commande
printf (format,expression, expression, ...) | commande
Ecriture des expressions séparées par OFS et terminées par ORS sur l’entrée de
la commande.

Département d’Informatique 17
Université de la Méditerrannée
C. Aperghis-Tramoni

Les formats.

La fonction printf implique la définition d’un format.

Caractère Format de Sortie


c Tout caractère ASCII.

d La partie entière d'un nombre.

e Nombre réel sous la forme [-]d.ddddddE[+/-]dd.

f Nombre réel sous la forme [-]ddd.dddddd.

g Le plus court entre e et f avec suppression des zéros.

o Nombre octal non signé.

s Toute chaine de caractères.

x Nombre hexadecimal non signé.

% Ecriture d'un % si aucun argument n'est présent.

Département d’Informatique 18
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemples de formats.
Format Contenu de var printf ("Format";var)
"'%c'\n" 83 's'
"'%d'\n" 83.5 '83'
"'%5d'\n" 83.5 ' 83'
"'%e'\n" 83.5 '8.350000e+01'
"'%f'\n" 83.5 '83.500000'
"'%7.2f'\n" 83.5 ' 83.50'
"'%g'\n" 83.5 '83.5'
"'%6g'\n" 83.5 ' 83.5'
"'%o'\n" 83 '123'
"'%06o'\n" 83.5 '000123'
"'%x'\n" 83 '53'
"'%s'\n" "ecole" 'ecole'
"'%10s'\n" "ecole" ' ecole'
"'%-10s'\n" "ecole" 'ecole '
"'%.3s'\n" "ecole" 'eco'
"'%10.3s'\n" "ecole" ' eco'
"'%-10.3s'\n" "ecole" 'eco '

Département d’Informatique 19
Université de la Méditerrannée
C. Aperghis-Tramoni

Les déclarations.
L’un des principaux attraits de awk, et ce qui en fait sa puissance, est qu’il n’y a
ni déclaration de variable ni déclaration de type.

Ainsi une variable peut avoir le type ‘chaine de caractères’ ou nombre.


Elle peut même avoir simultanément les deux types. Ainsi, awk convertira
la valeur d’une chaine en un nombre ou inversement au moment de l’exécution
du programme.
Ici "Marc" est une variable qui
Exemple : reçoit la valeur numérique 17.

/es2i/staff/chris : cat declare


$1 == "Marc" { On change le contenu du champ 3 (consommation)
pour le remplacer par la somme du champ 3 et de
Marc = 17 la variable Marc.
$3 = $3 + Marc
Ici "Marc" est chaine = $1 " : ceci ne veut rien dire, "
le critère de
sélection ($1).
print chaine, $3
}
/es2i/staff/chris : nawk -f declare Chauffeurs
Marc : ceci ne veut rien dire, 34
/es2i/staff/chris :

Département d’Informatique 20
Université de la Méditerrannée
C. Aperghis-Tramoni

Expressions, Collisions.
Le système appelle “Pattern” que nous traduirons par modèle, les expressions
utilisées pour sélectionner les diverses lignes d’un fichier.

Lorsqu’une forme est reconnue (“Matchée”), l’action écrite est alors exécutée.

Il existe plusieurs façons de sélectionner un modèle.

-> Comparaison.
-> Calcul.
-> Texte.
-> Combinaison de diverses sélections par des opérateurs logiques.

Département d’Informatique 21
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemples de sélections.
Forme de sélection. Exemples. Sélection réalisée.
Exécution du programme inclus
BEGIN BEGIN avant toute lecture du
fichier.
Exécution du programme inclus
END END aprés lecture de la fin de
fichier.
Exécution du programme inclus
Expression logique. NF > 5 si le nombre de champs de la
ligne est supérieur à 5.
Comparaison de Exécution du programme inclus
chaines de /Renault/ si la ligne contient la
caractères. chaine /Renault/.
Exécution du programme inclus
Compositions de
NF > 5 && /To/ si la ligne contient plus de
sélections.
5 champs et la chaine /To/.
Exécution du programme inclus
Intervalle. NR == 10,NR == 20 sur les lignes 5 à 20 du
fichier.

Département d’Informatique 22
Université de la Méditerrannée
C. Aperghis-Tramoni

Sélection par comparaison.


Les symboles utilisés sont les comparateurs usuels : <, <=, ==, !=, >=, >

Ils peuvent être utilisés à la fois sur les nombres et sur les chaines.

Soit par exemple à imprimer la liste de ceux qui parcourent plus de 500 KM
par jour en les faisant suivre de la mention “roule beaucoup”.

/es2i/staff/chris : nawk '$4 >= 500 {print $1," roule beaucoup"} ' Chauffeurs
Robert roule beaucoup
Serge roule beaucoup
Luc roule beaucoup
/es2i/staff/chris :

Département d’Informatique 23
Université de la Méditerrannée
C. Aperghis-Tramoni

Sélection par calcul.


Selectionner ceux qui coutent plus de 250 francspar semaine
et l’imprimer ainsi que le nom.

/es2i/staff/chris : nawk '$3*$4*$5/100 >= 250 {print $1," coute ", $3*$4*$5/100,
"francs par semaine."} ' Chauffeurs
Robert coute 314.6 francs par semaine.
Norbert coute 300 francs par semaine.
Serge coute 519.2 francs par semaine.
Luc coute 468 francs par semaine.
/es2i/staff/chris :

Département d’Informatique 24
Université de la Méditerrannée
C. Aperghis-Tramoni

Sélection par texte.


Sélectionner tous ceux qui sont alphabetiquement avant Jean.
/es2i/staff/chris : nawk '$1 < "Jean" {print} ' Chauffeurs
Claude Citroen 8 350 3.50
Alain Renault 9 100 5.00
Francois Peugeot 20 350 3.50
Albert Peugeot 7 250 3.50
Charles Renault 12 300 5.50
/es2i/staff/chris :

Recherche par l’intermédiaire d’expressions régulières.


Sélectionner toutes les lignes contenant la chaine ‘au’.
/es2i/staff/chris : nawk '/au/ {print} ' Chauffeurs
Claude Citroen 8 350 3.50
Alain Renault 9 100 5.00
Marc Renault 17 250 5.50
Charles Renault 12 300 5.50
/es2i/staff/chris :

Département d’Informatique 25
Université de la Méditerrannée
C. Aperghis-Tramoni

Combinaisons de conditions.
Les opérateurs logiques sont les mêmes qu’en C :
&& -> Et
|| -> Ou
! -> Non

Sélectionner ceux qui conduisent des Peugeots et


dont la consommation est supérieure à 10 litres aux 100.
/es2i/staff/chris : nawk '$3 > 10 && $2 == "Peugeot" {print} ' Chauffeurs
Robert Peugeot 11 550 5.20
Francois Peugeot 20 350 3.50
Serge Peugeot 11 800 5.90
/es2i/staff/chris :

Qui conformément au théorème de de Morgan,


aurait pu s’écrire en utilisant les négations :
/es2i/staff/chris : nawk '!($3 <= 10 || $2 != "Peugeot") {print} ' Chauffeurs
Robert Peugeot 11 550 5.20
Francois Peugeot 20 350 3.50
Serge Peugeot 11 800 5.90
/es2i/staff/chris :

Département d’Informatique 26
Université de la Méditerrannée
C. Aperghis-Tramoni

BEGIN et END.
Lorsque BEGIN est utilise, les actions qui lui succèdent sont effectuées avant que
la première ligne du fichier ne soit lue.
Lorsque END est utilise, les actions qui lui succèdent sont effectuées aprés que la
dernière ligne du fichier soit lue.

Il est possible d’ecrire des programmes AWK


sans avoir nécessairement de fichier en entrée.
BEGIN et END ne supportent pas de combinaison.

Attention aux diverses implémentations.

Certaines supportent plusieurs BEGIN (END).


Dans ce cas, ils sont exécutés dans l’ordre dans lequel ils se présentent.

D’autres exigent de ne rencontrer qu’un BEGIN (END)

Département d’Informatique 27
Université de la Méditerrannée
C. Aperghis-Tramoni

Un exemple de présentation.

/es2i/staff/chris : cat edition /es2i/staff/chris : nawk -f edition Chauffeurs


BEGIN { print;
print "Nom Marque Cons KM Carb"; Nom Marque Cons KM Carb
print }
{print} Jean Peugeot 10 250 5.50
END { print; Claude Citroen 8 350 3.50
print "Nombre de lignes lues : ", NR; Pierre Toyota 14 150 5.00
print "Edition Termine."; Robert Peugeot 11 550 5.20
print } Alain Renault 9 100 5.00
/es2i/staff/chris : Marc Renault 17 250 5.50
Michel Citroen 10 350 5.20
Norbert Toyota 15 400 5.00
Francois Peugeot 20 350
3.50
Serge Peugeot 11 800 5.90
Luc Toyota 12 750 5.20
Albert Peugeot 7 250 3.50
Charles Renault 12 300 5.50

Nombre de lignes lues : 13


Edition Termine.

/es2i/staff/chris :

Département d’Informatique 28
Université de la Méditerrannée
C. Aperghis-Tramoni

Les manipulations de chaine.


En plus des expressions de traitement des expressions arithmétiques,
awk propose nombre des facilités pour manipuler les chaines de caractère.

Une chaine est constituée de zéro ou n caractères.


Elles peuvent être stockées dans des variabes ou apparaitre in extenso.

Toute expression peut être utilisée en tant qu’opérande de tout opérateur.


Si une expression qui a une valeur numérique est utilisée par un opérateur qui
requiert une chaine, alors elle est automatiquement transformée et réciproquement.

Opérateur Signification.
< Inférieur à.
<= Inférieur ou égal à.
== égal à.
!= Différent de.
>= Supérieur ou égal à.
> Supérieur à.
~ Reconnu par.
!~ non reconnu par.

Département d’Informatique 29
Université de la Méditerrannée
C. Aperghis-Tramoni

Les actions.
Les actions peuvent être de simples impressions {print}, des affectations ou des
ensembles de lignes comportant des éléments du vocabulaire non terminal du
langage, des définitions de fonctions etc ...

Les Expressions comportent des constantes, des variables, des affectations,


des appels de fonctions prédéfinies ou non.
print(f) (format, liste d'expressions)
if (expression) instructions
if (expression) instructions else instructions
while (expression) instructions
for (expression;expression;expression) instructions
for (variable in tableau) instructions
do (instructions) while (expression)
break
continue
next
exit
exit expression
{expression}

Département d’Informatique 30
Université de la Méditerrannée
C. Aperghis-Tramoni

Les expressions.
Les expressions les plus simples sont des blocs primaires constitués
de constantes, de variables, de séparateurs.

5 grandes catégories se combinent entre elles :

-> Arithmétiques
-> Comparaisons
-> Logiques
-> Conditionnelles
-> Affectations

A quoi il faut ajouter :

Les fonctions prédéfinies.


Les fonctions définies par l’utilisateur.

Département d’Informatique 31
Université de la Méditerrannée
C. Aperghis-Tramoni

Les constantes.
Chaines de caractères :

“Francois”
“Christian Aperghis”
“ “
“”
La précision maximale
Constantes numériques entières : dépend de la machine.
5000

Constantes numériques réelle :

1000,5
0.55E-3
1e6

Département d’Informatique 32
Université de la Méditerrannée
C. Aperghis-Tramoni

Les Variables.
Les variables peuvent être prédéfinies ou appartenir à l’usager.

Une variable n’est pas déclarée et ne comporte pas de type.

Le type est déterminé en fonction du contexte.

Le nom d’une variable est constitué de lettres, de chiffres et de soulignés.

Le premier caractère ne doit pas être un chiffre.

Une variable prédéfinie est globale et ne peut être modifiée.

Département d’Informatique 33
Université de la Méditerrannée
C. Aperghis-Tramoni

Les variables prédéfinies.


A chaque variable prédéfine est associée une valeur par défaut.

Variable. Signification. Défaut.


ARGC Nombre d'arguments de la ligne de commande. n.a.
ARGV Liste des arguments de la ligne de commande (Tableau). n.a.
FILENAME Nom du fichier courant. n.a.
FNR Nombre d'enregistrements du fichier courant. n.a.
FS Contrôle du séparateur de champ du fichier courant. " "
NF Nombre de champs de l'enregistrement courant. n.a.
NR Nombre d'enregistrements lus depuis le début. n.a.
OFMT Format de sortie pour les nombres. "%.6g"
OFS Séparateur de sortie. " "
ORS Séparateur d'enregistrements. "\n"
RLENGTH Longueur d'une chaine validée par la fonction "match". n.a.
RS Contrôle du séparateur d'enregistrements en entrée.. "\n"
RSTART Début de la chaine validée par la fonction "match". n.a.
SUBSEP Séparateur d'indice. "\034"

Département d’Informatique 34
Université de la Méditerrannée
C. Aperghis-Tramoni

Test de variables (1).

/es2i/staff/chris : cat variables


BEGIN{
OFS = " "
print "Nombre d'arguments : ",ARGC "\n"
for (c in ARGV) print c,ARGV[c]
printf ("\n")
for (i=0;i<ARGC;i++) printf (" %s",ARGV[i])
printf ("\n\n")
printf ("Nom du fichier d'entree : %s\n\n",FILENAME)
}
{printf "FNR :%3d NR :%3d Debut ligne : %s %s \n", FNR, NR, $1, $2}
END{
printf ("\nNom du fichier d'entree : %s\n",FILENAME)
}
/es2i/staff/chris :

Département d’Informatique 35
Université de la Méditerrannée
C. Aperghis-Tramoni

Test de variables (2).


Exécution du programme précédent.
/es2i/staff/chris :nawk -f variables sonnet sonnet FNR : 14 NR : 14 Debut ligne :
Nombre d'arguments : 3 FNR : 15 NR : 15 Debut ligne : Maintenant je
FNR : 16 NR : 16 Debut ligne : Loger dedans
2 sonnet FNR : 17 NR : 17 Debut ligne : Et me
0 nawk FNR : 1 NR : 18 Debut ligne : Terre, ouvre-moi
1 sonnet FNR : 2 NR : 19 Debut ligne : Mon tresor,
FNR : 3 NR : 20 Debut ligne : Ou bien,
nawk sonnet sonnet FNR : 4 NR : 21 Debut ligne : Sous meme
FNR : 5 NR : 22 Debut ligne :
Nom du fichier d'entree : sonnet FNR : 6 NR : 23 Debut ligne : Le trait
FNR : 7 NR : 24 Debut ligne : Mon corps
FNR : 1 NR : 1 Debut ligne : Terre, ouvre-moi FNR : 8 NR : 25 Debut ligne : Aussi bien,
FNR : 2 NR : 2 Debut ligne : Mon tresor, FNR : 9 NR : 26 Debut ligne : Je ne
FNR : 3 NR : 3 Debut ligne : Ou bien, FNR : 10 NR : 27 Debut ligne :
FNR : 4 NR : 4 Debut ligne : Sous meme FNR : 11 NR : 28 Debut ligne : Quand ses
FNR : 5 NR : 5 Debut ligne : FNR : 12 NR : 29 Debut ligne : Le bonheur
FNR : 6 NR : 6 Debut ligne : Le trait FNR : 13 NR : 30 Debut ligne : Ayant de
FNR : 7 NR : 7 Debut ligne : Mon corps FNR : 14 NR : 31 Debut ligne :
FNR : 8 NR : 8 Debut ligne : Aussi bien, FNR : 15 NR : 32 Debut ligne : Maintenant je
FNR : 9 NR : 9 Debut ligne : Je ne FNR : 16 NR : 33 Debut ligne : Loger dedans
FNR : 10 NR : 10 Debut ligne : FNR : 17 NR : 34 Debut ligne : Et me
FNR : 11 NR : 11 Debut ligne : Quand ses
FNR : 12 NR : 12 Debut ligne : Le bonheur Nom du fichier d'entree : sonnet
FNR : 13 NR : 13 Debut ligne : Ayant de /es2i/staff/chris :

Département d’Informatique 36
Université de la Méditerrannée
C. Aperghis-Tramoni

Le test if ... else.


On touvera une syntaxe proche de celle du C, la différence résidant dans le fait qu’il
n’y a pas de déclaration de variable.
if ... else : Contrairement à une condition qui agit exclusivement sur la ligne courante
du fichier, un test peut agir sur toute variable globale ou de ligne et contrôler
l’exécution du programme.
Soit à calculer le coût moyen du kilomètre des Peugeots.

/es2i/staff/chris : cat cout.peugeot


$2 == "Peugeot" {n=n+1; cout = $3*$5/100 + cout}
END {
if (n>0)
{
print ("Cout moyen du kilometre parcouru en Peugeot :")
printf ("%4.2f francs calcule sur %d voitures.\n", cout/n,n)
}
else
print "Il n'y a pas de Peugeots parmis les ", NR, " voitures"
}
/es2i/staff/chris : nawk -f cout.peugeot Chauffeurs
Cout moyen du kilometre parcouru en Peugeot :
0.54 francs calcule sur 5 voitures.
/es2i/staff/chris :

Département d’Informatique 37
Université de la Méditerrannée
C. Aperghis-Tramoni

La boucle while.
Sachant que le prix du carburant augmente de 3% tous les six mois, calculez le prix de revient du
kilomètre de chaque voiture pour les deux ans qui viennent.
/es2i/staff/chris : cat prospect
BEGIN {printf ("\nMarque\tMaintenant\t6 mois \t12 mois\t18 mois\t24 mois\n")}
$2 == "Peugeot" { np = np+1; cp = $3*$5/100 + cp}
$2 == "Citroen" { nc = nc+1; cc = $3*$5/100 + cc}
$2 == "Renault" { nr = nr+1; cr = $3*$5/100 + cr}
$2 == "Toyota" { nt = nt+1; ct = $3*$5/100 + ct}
END { i = 1; printf ("\nPeugeot") i = 1; printf ("\nCitroen")
printf ("\t%7.2f\t",cp) printf ("\t%7.2f\t",cc)
while (i<=4) { cp = cp * 1.03 while (i<=4) { cc = cc * 1.03
i = 1; printf ("\nRenault") printf ("\t%6.2f",cc)
printf ("\t%7.2f\t",cr) i = i + 1}
while (i<=4) { cr = cr * 1.03 i = 1; printf ("\nRenault")
printf ("\t%6.2f",cr) printf ("\t%7.2f\t",cr)
i = i + 1} while (i<=4) { cr = cr * 1.03
i = 1; printf ("\nToyota") printf ("\t%6.2f",cr)
printf ("\t%7.2f\t",ct) i = i + 1}
while (i<=4) { ct = ct * 1.03 i = 1; printf ("\nToyota")
printf ("\t%6.2f",ct) printf ("\t%7.2f\t",ct)
i = i + 1} while (i<=4) { ct = ct * 1.03
printf ("\n\n") printf ("\t%6.2f",ct)
} i = i + 1}
printf ("\t%6.2f",cp) printf ("\n\n")
i = i + 1} }

Département d’Informatique 38
Université de la Méditerrannée
C. Aperghis-Tramoni

Exécution du programme.
/es2i/staff/chris : nawk -f prospect Chauffeurs

Marque 0 mois 6mois 12mois 18mois 24mois

Peugeot 2.72 2.80 2.88 2.97 3.06


Citroen 0.80 0.82 0.85 0.87 0.90
Renault 2.04 2.11 2.17 2.23 2.30
Toyota 2.07 2.14 2.20 2.27 2.33

/es2i/staff/chris :

Département d’Informatique 39
Université de la Méditerrannée
C. Aperghis-Tramoni

La boucle for.
Imprimer les données du fichier Chauffeurs en séparant les champs
par une tabulation.
/es2i/staff/chris : cat edite
{for (i = 1;i <= NF; i++) printf ("%10s\t",$i)
printf ("\n")
}
/es2i/staff/chris : nawk -f edite Chauffeurs
Jean Peugeot 10 250 5.50
Claude Citroen 8 350 3.50
Pierre Toyota 14 150 5.00
Robert Peugeot 11 550 5.20
Alain Renault 9 100 5.00
Marc Renault 17 250 5.50
Michel Citroen 10 350 5.20
Norbert Toyota 15 400 5.00
Francois Peugeot 20 350 3.50
Serge Peugeot 11 800 5.90
Luc Toyota 12 750 5.20
Albert Peugeot 7 250 3.50
Charles Renault 12 300 5.50
/es2i/staff/chris :

Département d’Informatique 40
Université de la Méditerrannée
C. Aperghis-Tramoni

Fonctions sur les chaines.


AWK permet de travailler sur les chaines de caractère
et comporte en outre quelques fonctions prédéfinies.

L’opération de concaténation est implicite,


/es2i/staff/chris : cat conc
{noms = noms $1 " - "}
END {print noms}
/es2i/staff/chris : nawk -f conc Chauffeurs
Jean - Claude - Pierre - Robert - Alain - Marc - Michel - Norbert - Francois -
Serge - Luc - Albert - Charles -
/es2i/staff/chris :

Département d’Informatique 41
Université de la Méditerrannée
C. Aperghis-Tramoni

La fonction split().
split(s,a) permet l’éclatement de la chaine s en fonction du caractère séparateur (FS).
Chaque élément ainsi défini est positionné dans le tableau a.

La valeur de retour de la fonction est la taille du tableau ainsi construit.

Eclatement de la chaine dont le prenier champ est ‘Francois’.

/es2i/staff/chris : cat split


/Francois/ {taille=split($0,tab)
for (i=1;i<=taille;i++) printf "L'element %d du tableau est %s\n",i,tab[i] }
/es2i/staff/chris : nawk -f split Chauffeurs
L'element 1 du tableau est Francois
L'element 2 du tableau est Peugeot
L'element 3 du tableau est 20
L'element 4 du tableau est 350
L'element 5 du tableau est 3.50
/es2i/staff/chris :

Département d’Informatique 42
Université de la Méditerrannée
C. Aperghis-Tramoni

La fonction gsub().
gsub(motif,remplacement,chaine)
permet de remplacer dans la chaine la forme définie par le motif.
/es2i/staff/chris : cat gsub
BEGIN {print "De la deliquescence du couple Automobile-Automobiliste.}
/es2i/staff/chris : cat gsub
BEGIN {print "Deliquescence du couple Automobile-Automobiliste."}
$1 == "Francois" {chaine =$1 $2}
END {while (chaine != "")
{
print chaine
x=gsub(/[a-zA-Z]$/,"",chaine) /es2i/staff/chris : nawk -f gsub Chauffeurs
} Deliquescence du couple Automobile-Automobiliste.
exit FrancoisPeugeot
} FrancoisPeugeo
/es2i/staff/chris : FrancoisPeuge
FrancoisPeug
FrancoisPeu
FrancoisPe
FrancoisP
Francois
Francoi
Franco
Franc
Fran
Fra
Fr
F
/es2i/staff/chris :

Département d’Informatique 43
Université de la Méditerrannée
C. Aperghis-Tramoni

Les tableaux.
Les tableaux serviront au stockage de toutes les données (chaines ou valeurs).
Ils ne sont pas déclarés.
Créer le tableau contenant les noms de tous les chauffeurs et les trier.
/es2i/staff/chris : cat tri
{Chauffeurs[NR] = $1}
END {for (i=NR;i>=1;i--)
for (j=2;j<=i-1;j++)
if (Chauffeurs[j] > Chauffeurs[j+1])
{
Temp=Chauffeurs[j]
Chauffeurs[j]=Chauffeurs[j+1]
Chauffeurs[j+1]=Temp
}
/es2i/staff/chris : nawk -f tri Chauffeurs
for (i=1;i<=NR;i++) print Chauffeurs[i]
Jean
}
Alain
/es2i/staff/chris :
Albert
Charles
Claude
Francois
Luc
Marc
Michel
Norbert
Pierre
Robert
Serge
/es2i/staff/chris :

Département d’Informatique 44
Université de la Méditerrannée
C. Aperghis-Tramoni

Les indices de tableaux.


La caractéristique principale des tableaux utilisés en awk, est que les indices ne sont
pas des uniquement des valeurs entières, mais peuvent être des chaines de caractères.
On les appelle ces structures des tableaux associatifs.

Compter le nombre de voitures de chaque marque.


es2i/staff/chris : cat tableau
/Peugeot/ {Nombre["Peugeot"] +=1}
/Renault/ {Nombre["Renault"] +=1}
/Citroen/ {Nombre["Citroen"] +=1}
/Toyota/ {Nombre["Toyota"] +=1}
END {
print "Nombre de Peugeots : ", Nombre["Peugeot"]
print "Nombre de Renaults : ", Nombre["Renault"]
print "Nombre de Citroens : ", Nombre["Citroen"]
print "Nombre de Toyotas : ", Nombre["Toyota"]
}
/es2i/staff/chris : nawk -f tableau Chauffeurs
Nombre de Peugeots : 5
Nombre de Renaults : 3
Nombre de Citroens : 2
Nombre de Toyotas : 3
/es2i/staff/chris :

Département d’Informatique 45
Université de la Méditerrannée
C. Aperghis-Tramoni

Les fonctions.
Comme dans la majorité des langages, il est possible à l’usager
de définir ses propres fonctions.

function nom (liste-de-paramètres) {Liste-d’instructions}

La définition du corps des fonctions est entièrement


séparée du corps du programme de base.

Le corps de la fonction peut comporter l’instruction


“return”
qui a pour effet de renvoyer une valeur ou un état
vers l’instruction appelante.

Département d’Informatique 46
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemple de fonction.
Déterminer le carburant
/es2i/staff/chris : cat fonction utilisé en fonction du prix.
{printf ("%s roule au %s\n",$1,carburant($5))}
function carburant(prix)
{
if (prix < 4.00) { return "Diesel"}
if (prix <= 5.30) { return "Super sans plomb"}
if (prix > 5.30) { return "Super"}
}
/es2i/staff/chris :
/es2i/staff/chris : nawk -f fonction Chauffeurs
Jean roule au Super
Claude roule au Diesel
Pierre roule au Super sans plomb
Robert roule au Super sans plomb
Alain roule au Super sans plomb
Marc roule au Super
Michel roule au Super sans plomb
Norbert roule au Super sans plomb
Francois roule au Diesel
Serge roule au Super
Luc roule au Super sans plomb
Albert roule au Diesel
Charles roule au Super
/es2i/staff/chris :

Département d’Informatique 47
Université de la Méditerrannée
C. Aperghis-Tramoni

Les entrées…
Nous avons déjà vu une possibilité de fournir des données à la commande awk,
c’est d’utiliser un fichier qui contient les données et de soummettre ce fichier au
traitement d’un programme qui peut être soit explicité dans la commande ou stocké
lui aussi dans un fichier programme.
awk ‘programme’ fichier-de-données
awk -f fichier-de-programme fichier-de-données

Il aurait été possible d’utiliser les tubes.


/es2i/staff/chris : grep ‘Peugeot’ Chauffeurs | nawk ‘$4>=500 {print $1,” roule beaucoup”} ‘
Robert roule beaucoup
Serge roule beaucoup
/es2i/staff/chris :

Département d’Informatique 48
Université de la Méditerrannée
C. Aperghis-Tramoni

La fonction getline.

La fonction getline lit l’enregistrement suivant sur l’entrée et incrémente NR.


Si il n’y a pas d’erreur, elle retourne la valeur 1.
Si c’est la fin de fichier, elle retourne la valeur 0.
Si il y a un problème, elle retourne la valeur -1.
Lecture de la ligne courante du fichier Chauffeurs :
getline < “Chauffeurs”
Placer dans la variable enr la ligne courante du fichier Chauffeurs :
getline x < “Chauffeurs”

Ainsi, tous les programmes vus jusqu’ici peuvent être réécrits placés
dans BEGIN en utilisant la fonction getline.
L’exécution est alors réalisée par la commande :
awk -f fichier-de-programme

Département d’Informatique 49
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemple de fonction getline.


/es2i/staff/chris : cat getline
BEGIN {
while (getline < "Chauffeurs" > 0)
{
if (NF != 5) {print $0 "Nombre de champs different de 5"}
if ($3 > 15) {print $1 " semble consommer beaucoup."}
if ($4 > 500) {print $1 " roule beaucoup."}
if ($4 < 200) {print $1 " roule peu."}
if ($5 > 5.50) {print $1 " paye son essence un peu cher."}
}
}
/es2i/staff/chris : nawk -f getline Chauffeurs
Pierre roule peu.
Robert roule beaucoup.
Alain roule peu.
Marc semble consommer beaucoup.
Francois semble consommer beaucoup.
Serge roule beaucoup.
Serge paye son essence un peu cher.
Luc roule beaucoup.
/es2i/staff/chris :

Département d’Informatique 50
Université de la Méditerrannée
C. Aperghis-Tramoni

Interactions.
Comme pour toute commande unix, la sortie dirigée de manière
standard dur stdout par print ou printf, peut être redirigée au
moyen de la redirection (>) vers tout fichier ou pipée (|) vers
une autre commande.
awk ‘{print $1}’ Chauffeurs > noms
awk ‘{print $2}’ Chauffeurs >> noms
awk ‘{print $1}’ Chauffeurs| cat
cat Chauffeurs | awk ‘{print $1}’

Département d’Informatique 51
Université de la Méditerrannée
C. Aperghis-Tramoni

La fonction system.
La commande ‘system (expresion)’ exécute la commande “expression”
donnée sous forme de chaine de caractères.
/es2i/staff/chris : cat system
BEGIN {
system("ps")
}
/es2i/staff/chris : nawk -f system
PID TTY TIME COMMAND
2841 ttyq0 0:00 ps
2840 ttyq0 0:00 sh
2648 ttyq0 0:00 csh
2839 ttyq0 0:00 nawk
/es2i/staff/chris :

Département d’Informatique 52
Université de la Méditerrannée
C. Aperghis-Tramoni

Les modèles de recherche


sur les chaines.

Type Signification.
Sélectionne la ligne courante lorsqu’une sous
/expression régulière/ chaine est valide en fonction de l’expression
régulière.

Sélectionne la ligne courante si la chaine


expression~/expression régulière/ “expression” contient une sous chaine valide
en fonction de l’expression régulière.

Sélectionne la ligne courante si la chaine


expression!~/expression régulière/ “expression” ne contient pas une sous chaine
valide en fonction de l’expression régulière.

Département d’Informatique 53
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemples

Quelles sont toutes les lignes qui contiennent le modèle ‘ne’.


/es2i/staff/chris : nawk '/ne/' sonnet
Ou bien, si tu ne peux, o terre, cache moi
Je ne saurais plus vivre, et me fache d'attendre.
Ayant de leurs rayons mon ame gouvernee.
Et me fit de ses pieds accomplir ma journee.
/es2i/staff/chris :

Quelles sont toutes les lignes qui contiennent le modèle ‘ ne ‘


en fait, le mot ‘ne’..
/es2i/staff/chris : nawk '/ ne /' sonnet
Ou bien, si tu ne peux, o terre, cache moi
Je ne saurais plus vivre, et me fache d'attendre.
/es2i/staff/chris :

Département d’Informatique 54
Université de la Méditerrannée
C. Aperghis-Tramoni

L'opérateur ~ (tilda).

Si la chaine à laquelle on désire soumettre l’expression régulière n’est pas


dans la variable prédéfinie $_ l’opérateur =~ va nous permettre de
soumettre l’expression régulière qui se trouve à sa droite à la variable qui
se trouve à sa gauche. Le résultat de cette opération est “vrai” si une
concordance est trouvée, “faux” sinon.

Département d’Informatique 55
Université de la Méditerrannée
C. Aperghis-Tramoni

Application.
Trouver toutes les lignes dans /es2i/staff/chris : nawk '$1 ~/e/' sonnet
lesquelles le premier champ Terre, ouvre-moi ton sein, et me laisse reprendre
Le trait qui la tua devait faire descendre
contient au moins un “e”.
Je ne saurais plus vivre, et me fache d'attendre.
Le bonheur de les voir, a l'heure je vivais,
Maintenant je suis mort : la Mort qui s'en alla
Loger dedans ses yeux, en parlant m'appela,
/es2i/staff/chris :

Trouver toutes les lignes dans /es2i/staff/chris : nawk '$1 !~/e/' sonnet
lesquelles le premier champ Mon tresor, que ta parque a cache dessous toi;
ne contient pas de “e”. Ou bien, si tu ne peux, o terre, cache moi
Sous meme sepulture, avec sa belle cendre.
Remarques :
Mon corps aupres du sien pour finir mon emoi;
Le premier champ d’une ligne Aussi bien, vu le mal qu'en sa mort je recoit,
vide ne contient pas de ‘e’.
Le premier champ de la ligne Quand ses yeux m'eclairaient, et qu'en terre j'avais
ne contient pas un ‘e’, il contient Ayant de leurs rayons mon ame gouvernee.
un ‘E’.
Et me fit de ses pieds accomplir ma journee.
/es2i/staff/chris :

Département d’Informatique 56
Université de la Méditerrannée
C. Aperghis-Tramoni

Les expressions régulières.


Ce sont des expressions spécifiques contenant des symboles particuliers
permettant la sélection de n’importe quelle sous chaine.
Une expression régulière est toujours placée entre deux slash.
(/expression régulière/).
Métacaractères.
Ce sont des aractères réservés : \ ^ $ [ ] | ( ) * + ?
Si l’on veut exprimer un de ces caractères, il est indispensable de le faire
précéder d’un antislash \

\$ pour le caractère $
\\ pour le caractère \
De plus

^ permet de sélectionner un début de chaine.


$ permet de sélectionner une fin de chaine.
. permet de sélectionner un caractère.

Département d’Informatique 57
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemples.
^F : Recherche d’un “F” au début de la chaine.
e$ : Recherche d’un “e” en fin de chaine.
^le$ : Recherche de la chaine composée des deux caractères “le”.
^.$ : Recherche de la chaine composée d’un seul caractère.
... : Recherche de toute chaine composée de trois caractères.
\.$ : Recherche d’un point “.” en fin de chaine.

Quelles sont les lignes qui commencent par un ‘L’.


/es2i/staff/chris : nawk '/^L/' sonnet
Le trait qui la tua devait faire descendre
Le bonheur de les voir, a l'heure je vivais,
Loger dedans ses yeux, en parlant m'appela,
/es2i/staff/chris :

Département d’Informatique 58
Université de la Méditerrannée
C. Aperghis-Tramoni

Exemples.
Quelles sont les lignes qui se terminent par un ‘e’.
/es2i/staff/chris : nawk '/e$/' sonnet
Terre, ouvre-moi ton sein, et me laisse reprendre
Le trait qui la tua devait faire descendre
/es2i/staff/chris :
Imprimer les lignes blanches !!!
/es2i/staff/chris : nawk '/^$/' sonnet

/es2i/staff/chris :
Quelles sont les lignes qui se terminent par un ‘;’.
/es2i/staff/chris : nawk '/\;$/' sonnet
Mon tresor, que ta parque a cache dessous toi;
Mon corps aupres du sien pour finir mon emoi;
/es2i/staff/chris :

Département d’Informatique 59
Université de la Méditerrannée
C. Aperghis-Tramoni

Les classes de caractères.


Une expression régulière consistant en un groupe de caractères
entre crochets est appelée classe de caractères.
Si le caractère ^ précède la classe (à l’intérieur des crochets)
alors il s’agit de la classe complémentaire.
[AEIOU] : Sélection des caractères A, E, I, O, U.
[^AEIOU] : Sélection de tous les caractères sauf A, E, I, O, U.
^[^AEIOU] : Sélection de tous les caractères en début de chaine sauf A, E, I, O, U.
^[^a-z-] : Sélection de toute chaine de un caractère n’étant ni une minuscule ni un -.
[a-zA-Z][0-9] : Sélection de toute chaine de deux caractères,
une lettre majuscule ou minuscule suivie d’un chiffre.
Remarque :
A l’itérieur d’une classe de caractères, tout caractère admet sa signification
propre, sauf \ et ^placé au début et - entre deux caractères.
[.] : Sélection du caractère “.”
^[^^] : Sélection de tout caractère en début de chaine sauf “^”.

Département d’Informatique 60
Université de la Méditerrannée
C. Aperghis-Tramoni

Les opérateurs binaires.


Il y a deux opérateurs binaires sur les expressions régulières :
l’intersection (et)
l’union (ou)
Si r1 et r2 sont deux expressions régulières, alors :
r1 | r2 sélectionne toute chaine validée par r1 ou par r2.
(r1)(r2) sélectionne toute chaine de la forme AB, ou r1 valide A et r2 valide B.
Trouver toutes les lignes contenant deux caractères quelconques suivis de la chaine “ai”
/es2i/staff/chris : nawk '/([a-zA-Z][a-zA-Z])(ai)/' sonnet
Terre, ouvre-moi ton sein, et me laisse reprendre
Le trait qui la tua devait faire descendre
Je ne saurais plus vivre, et me fache d'attendre.
Quand ses yeux m'eclairaient, et qu'en terre j'avais
Le bonheur de les voir, a l'heure je vivais,
/es2i/staff/chris :

Département d’Informatique 61
Université de la Méditerrannée
C. Aperghis-Tramoni

Les opérateurs unaires.


Les opérateurs + * et ? sont utilisés pour spécifier
des répétitions dans les expressions régulières.
(r)* : Toute chaine consistant en zéro ou n sous chaines consécutives de modèle r.
(r)+ : Toute chaine consistant en une ou n sous chaines consécutives de modèle r.
(r)? : Toute chaine de modèle r ou la chaine nulle..
A* : La chaine nulle ou A ou AA ou AAA ....
Ab*A : La chaine AA ou AbA ou AbbA ....
Ab?A : La chaine AA ou AbA
Ab+A : La chaine AbA ou AbbA ....
Abb*A : La chaine AbA ou AbbA ....
[A-Z]+ : Toute chaine de une ou plusieurs lettres majuscules.
(AA)+e : La chaine AAe ou AAAAe ou AAAAAAe ....
Reconnaissance d’un nombre réel comportant un signe optionnel
et un exposant optionnel :

^[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eE][+-]?[0-9]+)?$

Département d’Informatique 62
Université de la Méditerrannée
C. Aperghis-Tramoni

Récapitulatif.
EXPRESSION MODELE RECONNU
c Tout non métacaractère c.
\m Une séquence de tabulation ou tout métacaractère m pris au sens litéral.
^ Test effectué au début de la chaine.
$ Test effectué à la fin de la chaine.
. Tout caractère sauf une fin de ligne.
[c1c2...] Tout caractère expressément listé entre les crochets.
[^c1c2...] Tout caractère exepté ceux qui sont expressément listés entre les crochets.
[c1-c2] Tout caractère appartenant à l’intervalle c1 c2, bornes comprises.
r1|r2 Toute chaine de caractères validée soit par r1 soit par r2.
Toute chaine de caractères de type AB, dans laquelle l’expression régulière
(r1)(r2)
r1 valide A et l’expression régulière r2 valide B.
(r)* Zéro à n chaines consécutives validées par l’expression régulière r.
(r)+ Une à n chaines consécutives validées par l’expression régulière r.
(r)? Toute chaine validée par l’expression r, chaine vide incluse.
(r) Toute chaine validée par l’expression r, chaine vide exclue.

Département d’Informatique 63
Université de la Méditerrannée
C. Aperghis-Tramoni

Les compositions de modèles.


&& -> Et
|| -> Ou
Nous avons déja évoqué les compositions de modèles. ! -> Non
Un intervale de modèles est un doublet Mod1,Mod2
de modèles séparés par une virgule.
Un intervalle de modèles valide toutes les lignes comprises entre la première
occurence de Mod1 et l’occurence suivante de Mod2.
Si Mod1 et Mod2 font partie de la même ligne alors (en théorie)
cette ligne et cette ligne seulement est sélectionnée.
Editer toutes les lignes /es2i/staff/chris : nawk '/bien/,/mal/' sonnet
comprises entre celle Ou bien, si tu ne peux, o terre, cache moi
qui contient le mot Sous meme sepulture, avec sa belle cendre.
‘bien’ et celle qui Le trait qui la tua devait faire descendre
contient le mot ‘mal’. Mon corps aupres du sien pour finir mon emoi;
Aussi bien, vu le mal qu'en sa mort je recoit,
/es2i/staff/chris :

Département d’Informatique 64
Université de la Méditerrannée