La commande awk permet d'appliquer un certain nombre d'actions sur un fichier. La syntaxe est inspirée du C

awk [-Fs] [-v variable] [-f fichier de commandes] 'program' fichier

• -F Spécifie les séparateurs de champs
• -v Définie une variable utilisée à l'intérieur du programme.
• -f Les commandes sont lu à partir d'un fichier.

Le program est une suite d'action de la forme : motif { action } , le motif permet de determiner sur quels enregistrements est appliquée l'action. Si le motif existe dans l'enregistrement, l'action sera appliquée à la ligne .

• Par exemple, pour vérifier certains enregistrements du fichier /etc/passwd:

 awk 'BEGIN { print "Verification du fichier /etc/passwd pour ...";
              print "- les utilisateurs avec UID = 0 " ;
              print "- les utilisateurs avec UID >= 60000" ;
              FS=":"}
      $3 == 0 { print "UID 0 ligne "NR" :\n"$0 }
      $3 >= 60000  { print "UID >= 60000 ligne "NR" :\n"$0 }
      END   { print "Fin" }
' /etc/passwd 

Résultat :

Verification du fichier /etc/passwd pour ...
- les utilisateurs avec UID = 0
- les utilisateurs avec UID >= 60000
UID 0 ligne 5 :
root:*:0:b:administrateur:/:/bin/sh
UID >= 60000 ligne 14 :
clown:*:61000:b:utilisateur en erreur:/home/clown:/bin/sh
Fin

• Par exemple, pour vérifier le libellé du groupe 20 dans /etc/group:

 awk 'BEGIN { print "Verification du fichier /etc/group";
              print "le groupe 20 s'appelle t-il bien users ? " ;
              FS=":"}
      $1 == "users" && $3 ==20 { print "groupe "$1" a le GID "$3" !" }
      END   { print "Fin" }
' /etc/group 

Résultat :

Verification du fichier /etc/group
le groupe 20 s'appelle t-il bien users ?
groupe users a le GID 20 !
Fin

• Par exemple, pour afficher un interval de lignes avec leur numéro:

 awk 'NR == 5 , NR == 10 {print NR" : " $0 }' fichier 

Imprime de la ligne 5 à la ligne 10 , chaque ligne précédée par son numéro

Les instructions sont des blocs définis par des accolades. Ces blocs d'instructions sont exécutés (selon leurs conditions) durant la lecture du fichier, à chaque enregistrement. De plus, deux blocs spéciaux permettent d'ajouter des instructions à exécuter avant la lecture du premier enregistrement (le bloc BEGIN) et après la lecture du dernier enregistrement (le bloc END).

Lorsqu'un enregistrement est lu, il est placé dans la variable $0 (à ne pas confondre avec la variable $0 de Bash et Perl). L'enregistrement est ensuite scindé en plusieurs parties dans un tableau interne, allant de $1 à $NF, en utilisant FS comme séparateur de champs (à l'instar d'un split() automatique). En lignes de commandes, la suite de commandes Awk est à placer entre apostrophes. Par exemple :

$ awk '{print "ligne",NR,": ",$0," [nombre de champs:",NF,"] [premier champ:",$1,"] [dernier champ:",$NF,"]"}' ./fichier.txt

ligne 1 : ceci est un fichier [nombre de champs: 4 ] [premier champ: ceci ] [dernier champ: fichier ]

ligne 2 : qu'il est bien [nombre de champs: 3 ] [premier champ: qu'il ] [dernier champ: bien ]

L'une des fonctions les plus utilisées est certainement la fonction print, qui permet l'affichage de texte et variables, en les séparant par une virgule. Les champs sont ensuite séparés par la valeur de la variable OFS (un espace par défaut, voir l'exemple ci-dessus).

La fonction printf(), de syntaxe similaire à celle de C,permet d'afficher les données, de formater la mise en page et l'affichage des nombres. Exemple dans un bloc final (END), pour récupérer le nombre de lignes parcourues :

$ awk 'END {printf("| %-20s | %-12s |\n| %-20s | %-12i |\n","fichier",FILENAME,"nombre de lignes",FNR)}' fichier.txt

| fichier              | fichier.txt   |
| nombre de lignes     | 3             |

Les variables %s et %i sont respectivement remplacées par une chaîne de caractères et un entier. En ajoutant %-20s, on place cette valeur dans un espace de 20 caractères en commençant par la gauche (%20s pour la droite). Le restant est rempli par des espaces, ce qui, dans l'exemple ci-dessus, aligne les tubes.

Les scripts peuvent renvoyer un code retour de sortie par la fonction exit <code retour>, par défaut égal à 0, et des commandes Shell peuvent être exécutées par la fonction system(), qui retourne le code de sortie de la commande.

$ awk 'NR==1 { system("ls -l "FILENAME) } { print $0 }' fichier.txt

-rw-r--r-- 1 dams dams 104 juil. 24 18:55 fichier.txt

bob;adresse;12 rue de la mouette

alice;adresse;3 avenue du goéland

charles;adresse;24 rue de l'albatros

L'instruction suivante est identique à print mais en utilisant un format

printf format , exp, exp` ou `printf (format,exp , exp )

Un format est une chaine de caractères et des constructeurs commencant par %

La sortie d'un print ou d'un printf peut être redirigée dans un fichier ou sur un pipe

Les noms de fichiers doivent être entre guillemets sinon ils sont considérés comme des variables

Exemple: le fichier fich.numerote contient le fichier fichier avec les lignes numérotées

awk ' { print NR " :" , $0 > "fich.numerote" } ' fichier 

Exemple: le fichier fich.numerote contient le fichier fichier avec les lignes numérotées sur 3 caractères

awk ' { printf "%3d : %s " , NR , $0 > "fich.numerote" } ' fichier |

Pour bien utiliser awk, il faut connaître les variables de base, au moins FS, NR et RS, utiles dans la plupart des scripts.

Les variables personnelles n'ont besoin ni d'être déclarées, ni d'être initialisées dans les blocs principaux. Il n'y a pas non plus de type à déclarer, elles sont auto-typées (attention toutefois aux mélanges entiers/caractères lors des opérations). Les champs du fichier fichier.txt précédent sont séparés par un point-virgule, aussi la variable de séparation de champs, FS, doit être modifiée avant la lecture du fichier, dans le bloc BEGIN. Les autres blocs d'instructions, qui ne sont pas précédés de BEGIN, END, ou de conditions, sont exécutés pour chaque enregistrement.

$ awk 'BEGIN{FS=";"} {print $3}' fichier.txt

12 rue de la mouette
3 avenue du goéland
24 rue de l'albatros

• Les opérateurs arithmétiques sont les opérations usuelles : + - * / % (reste division entière) et ^ (puissance). Tous les calculs sont effectués en virgule flottante.
• La syntaxe de l'affectation : var = expression
• On peut aussi utiliser les operateurs +=, -=, *=, /=, %= et ^= (x+=y équivaut à x=x+y)

Ces variables ont les memes propriétés que Les autres variables. Elles peuvent etre reaffectées. Quand $0 est modifiées, les variables $1,$2 … sont aussi modifiées ainsi que NF.Inversement si une des variables $i est modifiées, $0 est mise à jour.

Les champs peuvent etre specifiés par des expressions, comme $(NF-1) pour l'avant dernier champs.

Par exemple pour créer un nouveau fichier de mot de passe /etc/passwd.new en remplacant le shell /bin/ksh par /bin/posix/sh

 awk 'BEGIN { FS=":" ;
             OFS=":"}
      $NF != "/bin/ksh" { print $0 }
      $3 == "/bin/ksh" && NF == 7  { $7 = "/bin/posix/sh" ;
                                     print $0 } '
      /etc/passwd > /etc/passwd.new 

Les paramètres sont indiqués par leurs noms suivis d'un caractère = et de leurs valeurs, avant les noms des fichiers. Ils sont ensuite récupérés dans le script par leurs noms, sans caractère additionnel, après le bloc BEGIN (si défini). Par exemple, le script test.awk suivant (l'opérateur tilde est une condition de contenu) :

BEGIN{FS=";"; OFS=" : "}
$1 ~ nom {print $1,$3}

$ awk -f test.awk nom=alice fichier.txt

alice : 3 avenue du goéland

En plus de fonctions de base, Awk dispose également de fonctions dédiées aux traitements des chaînes de caractères (ou string en anglais), facilitant ce genre d'opérations. La liste de ces fonctions est la suivante :

La concaténation de chaîne de caractères s'effectue sans espace ni caractère spécifique.

Exemple pour numéroter les lignes du fichier

 awk '{ print NR " : " $0 }' fichier

Exemple pour afficher les actions executées lors du passage à l'état 2

 awk 'BEGIN { FS=":" ;
             OFS=":" ;
             print " Run Level 2 : Liste des actions "}
      $2 ~ /2/  { print "Keyword <<"$3">>, \n Tache <<"$4">>" }
      $2 == ""  { print "Keyword <<"$3">>, \n Tache <<"$4">>" }
' /etc/inittab > /etc/passwd.new 

Awk dispose également de fonctions dédiées aux traitements numériques. Celles-ci sont les suivantes :

Les fonctions personnelles peuvent être définies dans le script Awk, en dehors des blocs d'instructions, ou dans un autre script qui sera également appelé par l'option -f <script>.

Une fonction se définit par le mot-clé function suivi du nom de la fonction et de ses paramètres. Par exemple :

{
        x=$1
        a=$2
        y=magauss(x,a)
        print "magauss(",x,";",a,") =",y
}
function magauss(x,a){
        pi=3.1415927
        return (1/(pi*a^2))^(1/4) * exp(x) * exp(-x^2/(2*a^2))
}

$ echo "12 3" | awk -f test.awk

magauss( 12 ; 3 ) = 23.6772

Un tableau multidimensionnel peut également être passé en argument d'une fonction comme un simple tableau. De plus, les modifications faites dans la fonction sur un tableau passé en argument les modifient hors de la fonction également (les tableaux sont passés par références, les variables par valeurs).

Les conditions concernant l'enregistrement en cours de lecture peuvent être, de préférence, placées avant le bloc d'instructions. Dans ce cas, on n'indique pas l'instruction par défaut IF. À l'intérieur des blocs, les conditions sont de syntaxe généralement commune dans les langages scripts :

if (expression) {
 instruction
 ...
} [else {
 instruction
 …
}]

Dans le cas d'une seule instruction, les accolades peuvent être évitées. Plusieurs instructions sur une même ligne doivent être séparées par un point-virgule. L'opérateur réduit de condition ?: est également fourni (si l'expression est vraie, l'instruction 1 est exécutée, sinon l'instruction 2 est exécutée) :

expression ? instruction_1 : instruction_2

Dans le script test.awk suivant, si l'enregistrement contient (opérateur tilde) « bob » et si le quatrième champ est égal à « adresse », il affiche le cinquième champ, sinon, si le second est égal à « adresse », cela affiche le troisième champ. On modifie la variable FS pour séparer les champs selon le caractère point-virgule.

BEGIN{FS=";"}
$0 ~ "bob"{
 if ($4 == "adresse") print $5
 else if ($2 == "adresse") print $3
}

$ awk -f test.awk fichier.txt

12 rue de la mouette

Les boucles while, do…while et for sont disponibles.

while(condition){
 instruction
 ...
}

Dans la boucle do…while, du fait que la condition soit vérifiée après les instructions, celles-ci sont exécutées au moins une fois.

do{
 instruction
 ...
}while(condition)

La boucle for est assez classique dans sa syntaxe.

for (initialisation; condition; incrémentation){
 instructions
 …
}

Il existe aussi une variante de la boucle for pour les tableaux à simple dimension.

for (variable in tableau){
instructions
 …
}

De plus, les boucles peuvent être complétées par des instructions break pour en sortir et next pour passer à l'étape suivante.

Dans le script test.awk suivant, si l'enregistrement contient « bob » et si l'un des champs est égal à « adresse », il affiche le champ suivant. Si le champ « adresse » est à la fin, une ligne vide s'affiche à la place.

BEGIN{FS=";"}
$0 ~ "bob"{
 for (i=1; i<=NF; i++)
  if($i == "adresse") print $(i+1)
}

$ awk -f test.awk fichier.txt

12 rue de la mouette

Comme les variables, les tableaux n'ont pas besoin d'être déclarés. De plus, les tableaux sont associatifs : une clé peut être associée à une valeur unique ; autrement dit, les tableaux peuvent être des vecteurs ou des maps. On peut utiliser des tableaux de chaines de caractères et de nombres à une dimension:

• Il n'est pas nécessaire de les déclarer.
• La valeur par défaut est “” ou 0.
• Les indices sont des chaines de caractères.

Les expressions régulières permettent d'affiner les conditions en utilisant des méta-caractères spécifiques (man 7 regex). On trouve fréquemment l'usage des caractères suivants : ^ pour signaler une position en début de ligne, $ pour une position en fin de ligne, . pour un caractère quelconque, les crochets [ et ] pour une plage de caractères, + pour indiquer au moins un caractère défini précédemment, et * pour un nombre quelconque ou nul de caractères. Sous Awk, ces expressions régulières, à la norme POSIX, sont à placer entre deux slashs / et ne prennent pas en compte les variables (ce qui peut être assez contraignant).

Par exemple, pour vérifier les UID et GID dans le fichier /etc/passwd:

 awk 'BEGIN { print "Verification des UID et GID dans le fichier /etc/passwd";
              FS=":"}
      $3 !~ /^[0-9][0-9]*$/ {print "UID  erreur ligne "NR" :\n"$0 }
      $4 !~ /^[0-9][0-9]*$/ {print "GID  erreur ligne "NR" :\n"$0 }
      END   { print "Fin" }
' /etc/passwd 

Résultat :

Verification des UID et GID dans le fichier /etc/passwd
UID erreur ligne 14 :
clown:*:aaa:b:utilisateur en erreur:/home/clown:/bin:sh
GID erreur ligne 14 :
clown:*:aaa:b:utilisateur en erreur:/home/clown:/bin/sh
Fin