Awk 2 PDF

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 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.
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.
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
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.
C. Aperghis-Tramoni
Exemples de visualisation (1).

Impression ligne à ligne du fichier. $0 indique la totalité des champs.
/es2i/staff/chris : nawk '{print}'

Chauffeurs
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
/es2i/staff/chris :
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 :
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.
C. Aperghis-Tramoni
Applications simples.
Trouver tous les possesseurs de Renault.

/es2i/staff/chris : nawk '$2 == "Renault" {print}' Chauffeurs
/es2i/staff/chris : nawk '$2 == "Renault" {print}' Chauffeurs Chauffeurs
/es2i/staff/chris :
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.
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 :
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 :
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

/es2i/staff/chris : nawk '{if ($2 == "Peugeot") print}' Chauffeurs
/es2i/staff/chris :
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 :
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.
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 :
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.
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.
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 '
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 :
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.
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.
END END aprés lecture de la fin de
fichier.
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/.
Compositions de
NF > 5 && /To/ si la ligne contient plus de
sélections.
5 champs et la chaine /To/.
Intervalle. NR == 10,NR == 20 sur les lignes 5 à 20 du
fichier.
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 :
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 :
C. Aperghis-Tramoni
Sélection par texte.

Sélectionner tous ceux qui sont alphabetiquement avant Jean.
/es2i/staff/chris : nawk '$1 < "Jean" {print} ' Chauffeurs
/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
/es2i/staff/chris :
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
/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
/es2i/staff/chris :
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)
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
Francois Peugeot 20 350
3.50
Nombre de lignes lues : 13

Edition Termine.
/es2i/staff/chris :
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.
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}
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.
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
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.
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"
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 :
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 :
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 :
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} }
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 :
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
/es2i/staff/chris :
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 :
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 :
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 :
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 :
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 :
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.
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 :
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 :
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
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 :
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}’
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 :
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.
C. Aperghis-Tramoni
Exemples
Quelles sont toutes les lignes qui contiennent le modèle ‘ne’.

/es2i/staff/chris : nawk '/ne/' sonnet
Je ne saurais plus vivre, et me fache d'attendre.
Ayant de leurs rayons mon ame gouvernee.
/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
/es2i/staff/chris :
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.
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
contient au moins un “e”.
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 :
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’.
/es2i/staff/chris :
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.
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
Loger dedans ses yeux, en parlant m'appela,
/es2i/staff/chris :
C. Aperghis-Tramoni
Exemples.
Quelles sont les lignes qui se terminent par un ‘e’.
/es2i/staff/chris : nawk '/e$/' sonnet
/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;
/es2i/staff/chris :
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.
[ÂEIOU] : Sélection de tous les caractères sauf A, E, I, O, U.
^[ÂEIOU] : Sélection de tous les caractères en début de chaine sauf A, E, I, O, U.
^[â-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 “^”.
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
Quand ses yeux m'eclairaient, et qu'en terre j'avais
/es2i/staff/chris :
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]+)?$
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.
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 :

Awk 2 PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Awk 2 PDF

Titre original :

Transféré par

Droits d'auteur :

Formats disponibles

C.

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

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

Le trait qui la tua devait faire descendre

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

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

Jean Peugeot 10 250 5.50

Champs et Séparateurs (1).

Tous les types de données

Exemples de visualisation (1).

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

Exemples de visualisation (2).

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

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

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

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

Trouver tous les possesseurs de Renault.

Les fichiers programme.

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

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

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

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

Quelques exemples (1).

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

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

Les entrées sorties.

print expression, expression, ...

print expression, expression, ... > fichier

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

Caractère Format de Sortie

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.

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

/es2i/staff/chris : cat declare

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

Sélection par comparaison.

Sélection par calcul.

Sélection par texte.

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

Sélectionner ceux qui conduisent des Peugeots et

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

Il est possible d’ecrire des programmes AWK

Attention aux diverses implémentations.

Certaines supportent plusieurs BEGIN (END).

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

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

Nombre de lignes lues : 13

Les manipulations de chaine.

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

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

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

5 grandes catégories se combinent entre elles :

A quoi il faut ajouter :

Les fonctions prédéfinies.

Constantes numériques réelle :

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

Les modèles de recherche