Commande awk

Fonction

Cette commande permet de détecter dans les fichiers les lignes correspondant à un modèle spécifique et d'exécuter les actions spécifiées.

Syntaxe

awk [ -FEre ] [ -v Affectation ] ... { -f FichierProgramme | 'Programme' } [ [ Fichier ... | Affectation ... ] ] ...

Description

La commande awk utilise un ensemble d'instructions indiquées par l'utilisateur pour comparer un ensemble de fichiers, ligne par ligne, à des expressions régulières étendues indiquées par l'utilisateur. Elle exécute ensuite des actions sur toute ligne qui correspond aux expressions régulières étendues.

La recherche de modèles de la commande awk est plus générale que celle exécutée par la commande grep et permet à l'utilisateur d'effectuer plusieurs actions sur les lignes de texte saisies. Le langage de programmation de la commande awk ne requiert pas de compilation et autorise l'utilisateur à faire appel à des variables, des fonctions numériques, des fonctions de chaîne et des opérateurs logiques.

La commande awk est affectée par les variables LANG, LC_ALL, LC_COLLATE, LC_CTYPE, LC_MESSAGES, LC_NUMERIC, NLSPATH et PATH.

Cet article est consacré aux éléments suivants :

• Types d'entrée gérés par la commande awk
• Sortie de la commande awk
• Traitement des fichiers basé sur les enregistrements et les zones
• Langage de programmation de la commande awk
  • Modèles
  • Actions
  • Variables
  • Variables spéciales
• Options
• Exemples

Types d'entrée gérés par la commande awk

La commande awk gère deux types d'entrée : Les fichiers texte et les instructions programme.

Fichiers texte en entrée

Cette commande gère la recherche et l'exécution d'actions dans les fichiers texte en entrée. Les fichiers sont spécifiés comme suit :

• par le biais de la variable Fichier sur la ligne de commande ;
• en modifiant les variables spéciales ARGV et ARGC ;
• via une entrée standard si la variable Fichier n'est pas spécifiée.

Si vous spécifiez plusieurs fichiers par le biais de la variable Fichier, ils sont traités dans l'ordre indiqué.

Instruction de programme

Les instructions fournies par l'utilisateur déterminent les actions exécutées par la commande awk. Elles proviennent soit de la variable "Programme" spécifiée sur la ligne de commande, soit d'un fichier défini par l'option -f, en conjonction avec la variable FichierProgramme. Si plusieurs fichiers de programme sont indiqués, ils sont concaténés dans l'ordre spécifié et les instructions sont utilisées dans l'ordre qui en résulte.

Sortie de la commande awk

La commande awk génère trois types de sortie à partir des données que contient le fichier texte en entrée :

• Les données sélectionnées peuvent être imprimées sur la sortie standard sans modification du fichier en entrée.
• Des sections sélectionnées du fichier en entrée peuvent être modifiées.
• Les données sélectionnées peuvent être modifiées et imprimées sur la sortie standard, avec ou sans modification du contenu du fichier en entrée.

Un même fichier peut donner lieu à tous ces types de sortie. Le langage de programmation reconnu par la commande awk permet à l'utilisateur de rediriger la sortie.

Traitement des fichiers basé sur les enregistrements et les zones

Les fichiers sont traités comme suit :

1. La commande awk analyse ses instructions et effectue toute action dont l'exécution est spécifiée avant la lecture du fichier en entrée.

   L'instruction BEGIN en langage de programmation awk permet à l'utilisateur de spécifier l'exécution d'un ensemble d'instructions avant la lecture du premier enregistrement. Cette méthode se révèle particulièrement utile pour l'initialisation des variables spéciales.

2. Un enregistrement est lu dans le fichier en entrée.

   Il constitue un ensemble de données séparées par un séparateur d'enregistrements. La valeur par défaut du séparateur d'enregistrements correspond au caractère d'avance ligne, qui fait de chaque ligne du fichier un enregistrement distinct. Pour modifier sa valeur, utilisez la variable spéciale RS.

3. L'enregistrement est comparé à chaque modèle spécifié par les instructions de la commande awk.

   Les instructions de la commande peuvent spécifier la comparaison d'une zone déterminée au sein de l'enregistrement. Par défaut, les zones sont séparées par des caractères blancs (blancs ou tabulations). A chaque zone correspond une variable de zone. La variable $1 est affectée à la première zone d'un enregistrement, la variable $2 à la deuxième zone, et ainsi de suite. La variable $0 est affectée à l'enregistrement entier. Pour modifier le séparateur de zone, utilisez l'option -F sur la ligne de commande ou définissez la variable spéciale FS. Celle-ci gère les valeurs suivantes : Blanc, caractère unique ou expression régulière étendue.

4. Si l'enregistrement correspond à un modèle, toute action associée à celui-ci est exécutée sur l'enregistrement.
5. Une fois l'enregistrement comparé à chaque modèle et toutes les actions spécifiées exécutées, l'enregistrement suivant est lu dans le fichier en entrée. Le processus est alors répété jusqu'à ce que tous les enregistrements soient lus.
6. Si vous avez défini plusieurs fichiers en entrée, le fichier suivant est ouvert et le processus répété jusqu'à ce que tous les fichiers en entrée soient lus.
7. Une fois le dernier enregistrement du dernier fichier lu, la commande awk exécute toute instruction dont l'exécution doit avoir lieu après le traitement des fichiers en entrée.

   L'instruction END en langage de programmation awk permet à l'utilisateur de spécifier des actions dont l'exécution suit la lecture du dernier enregistrement. Ce processus est particulièrement utile pour l'envoi de messages relatifs aux tâches exécutées par la commande awk.

Langage de programmation de la commande awk

Le langage de programmation de la commande awk comprend des instructions exprimées comme suit :

Modèle { Action }

Si un enregistrement correspond au modèle indiqué ou qu'il contient une zone qui correspond au modèle, l'action connexe est alors exécutée. Vous pouvez spécifier un modèle sans définir d'action, auquel cas la ligne entière qui contient le modèle est écrite dans la sortie standard. Une action sans modèle est exécutée pour chaque enregistrement de fichier en entrée.

Modèles

La syntaxe du langage de la commande awk gère quatre types de modèle :

• Expressions régulières
• Expressions relationnelles
• Combinaisons de modèles
• .Modèles BEGIN et END

Expressions régulières

Les expressions régulières étendues utilisées par la commande awk sont similaires à celles de la commande grep. Sous sa forme la plus simple, une expression régulière étendue est une chaîne de caractères entourée de barres obliques. Supposons par exemple que le fichier fichier d'essai contienne les éléments suivants :

smawley, andy
smiley, allen
smith, alan
smithern, harry
smithhern, anne
smitters, alexis

Entrer la ligne de commande suivante :

awk '/smi/' fichier d'essai

imprimerait sur la sortie standard tous les enregistrements qui contiennent une occurrence de la chaîne smi. Dans cet exemple, le programme '/smi/' associé à la commande awk est un modèle sans action. La sortie est la suivante :

smiley, allen
smith, alan
smithern, harry
smithhern, anne
smitters, alexis

Les caractères spéciaux suivants permettent de composer des expressions régulières étendues :

awk '/smith+ern/' fichier d'essai

smithern, harry
smithhern, anne

awk '/smith?/' fichier d'essai

smith, alan
smithern, harry
smithhern, anne
smitters, alexis

awk '/allen 
| 
alan /' fichier d'essai

smiley, allen
smith, alan

awk '/a(ll)?(nn)?e/' fichier d'essai

smiley, allen
smithhern, anne

awk '/l{2}/' fichier d'essai

smiley, allen

awk '/t{2,}/' fichier d'essai

smitters, alexis

awk '/er{1, 2}/' fichier d'essai

smithern, harry
smithern, anne
smitters, alexis

awk '/sm[a-h]/' fichier d'essai

smawley, andy

awk '/sm[^a-h]/' fichier d'essai

smiley, allen
smith, alan
smithern, harry
smithhern, anne
smitters, alexis

awk '$1 ~ /n/' fichier d'essai

smithern, harry
smithhern, anne

awk '$2 ~ /^h/' fichier d'essai

smithern, harry

awk '$2 ~ /y$/' fichier d'essai

smawley, andy
smithern, harry

awk '/a..e/' fichier d'essai

smawley, andy
smiley, allen
smithhern, anne

awk '/a.*e/' fichier d'essai

smawley, andy
smiley, allen
smithhern, anne
smitters, alexis

/a\/\//

Séquences d'échappement gérées

La commande awk gère la plupart des séquences d'échappement utilisées par les conventions du langage C, ainsi que plusieurs autres séquences assimilées à des caractères spéciaux par la commande. Les séquences d'échappement sont les suivantes :

Expressions relationnelles

Les opérateurs relationnels < (inférieur à), > (supérieur à), <= (inférieur ou égal à), >= (supérieur ou égal à), = = (égal à) et ! = (différent de) permettent de définir des modèles. Ainsi, le modèle :

$1 < $4

met en correspondance les enregistrements dont la première zone est inférieure à la quatrième zone. Les opérateurs relationnels fonctionnent également avec les valeurs de chaîne. Exemple :

$1 =! "q"

extrait tous les enregistrements dont la première zone n'est pas un q. Vous pouvez également mettre en correspondance des valeurs de chaîne à partir de valeurs de classement. Exemple :

$1 >= "d"

met en correspondance tous les enregistrements dont la première zone débute par le caractère a, b, c ou d. Si aucune autre information n'est spécifiée, les variables de zone sont comparées en tant que valeurs de chaîne.

Combinaisons de modèles

Vous pouvez combiner les modèles à l'aide de trois options :

• Les intervalles sont spécifiés par deux modèles séparés par une virgule (,). Les actions sont exécutées sur chaque enregistrement, en commençant par celui qui correspond au premier modèle et ainsi de suite jusqu'à l'enregistrement qui correspond au second modèle. Exemple :

  /begin/,/end/

  met en correspondance l'enregistrement qui contient la chaîne begin, chaque enregistrement compris entre celui-ci et l'enregistrement contenant la chaîne end, ainsi que ce dernier .

• Les parenthèses ( ) permettent de regrouper les modèles.
• Les opérateurs booléens || (ou), && (et) et ! (pas) combinent les modèles pour former des expressions mises en correspondance si elles sont vraies. Si tel n'est pas le cas, aucune correspondance n'est établie. Ainsi, le modèle :

  $1 == "al" && $2 == "123"

  met en correspondance les enregistrements dont la première zone contient al et la deuxième zone, 123.

Modèles BEGIN et END

Les actions spécifiées par le modèle BEGIN sont exécutées avant la lecture de toute entrée. Celles indiquées par le modèle END sont exécutées après la lecture de toute entrée. Les modèles BEGIN et END multiples sont autorisés et traités dans l'ordre défini. Un modèle END peut précéder un modèle BEGIN dans les instructions du programme. Si un programme n'est composé que d'instructions BEGIN, les actions sont exécutées et aucune entrée n'est lue. Si un programme n'est composé que d'instructions END, toutes les entrées sont lues avant l'exécution des actions.

Actions

Il existe plusieurs types d'instructions d'action :

• Instructions d'action
• Fonctions intégrées
• Fonctions définies par l'utilisateur
• Instructions conditionnelles
• Instructions de sortie

Instructions d'action

Les instructions d'action sont entourées d'accolades ({ }). Si les instructions sont spécifiées sans modèle, elles sont exécutées sur chaque enregistrement. Vous pouvez spécifier plusieurs actions au sein des accolades, mais vous devez les séparer par un caractère d'avance ligne ou un point-virgule (;) et les instructions sont traitées dans l'ordre dans lequel elles apparaissent. Parmi les instructions d'action figurent :

Instructions arithmétiques

Les opérateurs mathématiques + (plus), - (moins), / (division), ^ (élévation à une puissance), * (multiplication), % (modulo) sont utilisés comme suit :

Expression Opérateur Expression

Ainsi, l'instruction :

$2 = $1 ^ 3

attribue la valeur de la première zone élevée à la puissance trois à la deuxième zone.

Instructions unaires

Les instructions unaires - (moins) et + (plus) fonctionnent comme dans le langage de programmation C :

+Expression ou -Expression

Instructions de type incrément ou décrément

Les instructions de préincrément et prédécrément fonctionnent comme dans le langage de programmation C :

++Variable ou --Variable

Les instructions de postincrément et postdécrément fonctionnent comme dans le langage de programmation C :

Variable++ ou Variable--

Instructions d'affectation

Les opérateurs d'affectation += (addition), -= (soustraction), /= (division), et *= (multiplication) fonctionnent comme dans le langage de programmation C, comme suit :

Variable += Expression

Variable -= Expression

Variable /= Expression

Variable *= Expression

Ainsi, l'instruction :

$1 *= $2

multiplie la variable de zone $1 par la variable de zone $2, puis attribue la nouvelle valeur à $1.

Le format des opérateurs d'affectation ^= (élévation à une puissance) et %= (modulo) est le suivant :

Variable1^=Expression1

ET

Variable2%=Expression2

Ils sont équivalents aux instructions du langage de programmation C suivantes :

Variable1=pow(Variable1, Expression1)

ET

Variable2=fmod(Variable2, Expression2)

où pow est le sous-programme pow et fmod, le sous-programme fmod.

Instructions de concaténation de chaîne

Pour concaténer les valeurs de chaîne, il convient de les indiquer côte à côte. Exemple :

$3 = $1 $2

affecte la concaténation des chaînes figurant dans les variables de zone $1 et $2 à la variable de zone $3.

Fonctions intégrées

Le langage de la commande awk utilise des fonctions arithmétiques, des fonctions de chaîne et des fonctions générales. L'instruction de fermeture d'un sous-programme est requise si vous souhaitez écrire les données dans un fichier, puis lire celui-ci ultérieurement dans le même programme.

Fonctions arithmétiques

Les fonctions arithmétiques suivantes exécutent les mêmes actions que les sous-programmes du langage C du même nom :

Fonctions de chaîne

Les fonctions de chaîne sont les suivantes :

Fonctions générales

Les fonctions générales sont les suivantes :

Fonctions définies par l'utilisateur

Les fonctions définies par l'utilisateur sont déclarées au format suivant :

Nom de fonction (Paramètre, Paramètre,...)  { Instructions }

Un programme de la commande awk peut faire référence à une fonction à tout moment et l'utilisation de cette dernière peut précéder sa définition. La portée de la fonction est globale.

Les paramètres d'une fonction sont scalaires ou tabulaires. Les paramètres sont propres à la fonction, mais toutes les autres variables sont globales. N'attribuez pas le même nom à des entités distinctes. Un paramètre ne doit par exemple pas porter le même nom qu'une fonction ou qu'une variable spéciale. Les variables à portée globale ne doivent pas porter le même nom qu'une fonction. Les scalaires et les tableaux ne doivent pas porter le même nom si leur portée est identique.

Le nombre de paramètres compris dans la définition d'une fonction ne correspond pas nécessairement au nombre de paramètres utilisés lorsque la fonction est appelée. Vous pouvez utiliser d'autres paramètres formels en tant que variables locales. Les paramètres scalaires supplémentaires possèdent à l'initialisation une valeur de chaîne équivalente à la chaîne vide et une valeur numérique égale à zéro (0). Les paramètres tabulaires supplémentaires sont initialisés en tant que tableaux vides.

Lorsqu'une fonction est appelée, aucun blanc n'est inséré entre son nom et la parenthèse ouvrante. Les appels de fonction peuvent être imbriqués et récursifs. Lorsqu'elles sont renvoyées par tout appel de fonction imbriqué ou récursif, les valeurs des paramètres de la fonction ne sont pas modifiées, à l'exception des paramètres tabulaires passés à titre de référence. L'instruction return peut être utilisée pour renvoyer une valeur.

Au sein d'une définition de fonction, les caractères d'avance ligne sont facultatifs avant l'accolade ouvrante ({) et après l'accolade fermante (}).

Exemple de définition de fonction :

function average ( g,n) 
  {
        for (i in g)
           sum=sum+g[i]
        avg=sum/n
        return avg
  } 

Un tableau, g, et une variable, n, ainsi que le nombre d'éléments que contient le tableau, sont passés à la fonction average. Celle-ci obtient alors une moyenne et la renvoie.

Instructions conditionnelles

La plupart des instructions conditionnelles en langage de programmation de la commande awk gèrent les mêmes syntaxe et fonction que les instructions conditionnelles en langage de programmation C. Toutes les instructions conditionnelles peuvent être regroupées à l'aide d'accolades ({ }). Vous pouvez utiliser en option un caractère d'avance ligne entre la section expression et la section instruction de l'instruction conditionnelle. Les caractères d'avance ligne et les points-virgules (;) permettent de séparer plusieurs instructions dans des accolades ({ }). Les six instructions conditionnelles en langage C sont :

Les cinq instructions conditionnelles en langage de programmation de la commande awk qui ne respectent pas les règles du langage C sont :

for (i in g)
   delete g[i];

Instructions de sortie

Les deux instructions de sortie du langage de programmation de la commande awk sont :

Variables

Les variables peuvent être de type scalaire, zone, tabulaire ou spécial. Leur nom ne doit pas débuter par un chiffre.

Vous pouvez simplement les référencer pour les utiliser. A l'exception des paramètres de fonction, elles ne sont pas explicitement déclarées. Les variables scalaires et les éléments de tableau non initialisés possèdent tous deux la valeur numérique zéro (0) et une valeur de chaîne égale à celle de la chaîne vide (" ").

Selon le contexte, les variables gèrent les valeurs numériques ou de chaîne. Chaque variable peut avoir une valeur numérique, une valeur de chaîne ou les deux à la fois. Exemple :

x = "4" + "8"

affecte la valeur 12 à la variable x. Pour les constantes de chaîne, les expressions doivent être mises entre guillemets (" ").

Il ne se produit aucune conversion explicite entre les nombres et les chaînes. Pour imposer le traitement d'une expression comme un nombre, ajoutez-lui zéro (0). Pour imposer le traitement d'une expression comme une chaîne, ajoutez une chaîne vide (" ").

Variables de zone

Les variables de zone sont désignées par le symbole du dollar ($) suivi d'un nombre ou d'une expression numérique. La variable $1 correspond à la première zone d'un enregistrement, la variable $2 à la deuxième zone, et ainsi de suite. La variable de zone $0 est affectée à l'enregistrement entier. Pour créer une variable de zone, affectez-lui une valeur. Affecter une valeur à une zone non existante, soit une zone supérieure à la valeur actuelle de la variable de zone $NF, impose la création des zones comprises entre les deux valeurs (réglées sur la chaîne vide), augmente la valeur de la variable spéciale NF et force la variable d'enregistrement $0 à être recalculée. Les nouvelles zones sont séparées par le séparateur de zone en cours (qui correspond à la valeur de la variable spéciale FS). Les séparateurs de zone par défaut sont le caractère blanc et la tabulation. Pour modifier le caractère défini, utilisez l'option -F ou affectez à la variable spéciale FS une autre valeur dans le programme de la commande awk.

Tableaux

Les tableaux sont initialement vides et leur taille est modifiée dynamiquement. Ils sont représentés par une variable à indice entre crochets ([ ]). Les indices, ou identificateur d'élément, peuvent être des nombres de chaînes, qui proposent un type de fonction de tableau associatif. Ainsi, le programme :

/red/  { x["red"]++ }
/green/ { y["green"]++ }

incrémente le nombre de compteurs red et de compteurs green.

Plusieurs indices peuvent être affectés aux tableaux, à l'instar des tableaux multidimensionnels dans certains langages de programmation. Puisque les tableaux de programmation de la commande awk sont monodimensionnels, les indices séparés par une virgule sont convertis en une chaîne unique en concaténant les valeurs de chaîne des expressions distinctes, chaque expression étant séparée par la valeur de la variable d'environnement SUBSEP. De ce fait, les deux opérations d'index suivantes sont équivalentes :

x[expr1, expr2,...exprn]

ET

x[expr1SUBSEPexpr2SUBSEP...SUBSEPexprn]

Si vous utilisez l'opérateur in, une valeur Index multidimensionnelle doit être mise entre parenthèses. A l'exception de l'opérateur in, toute référence à un élément de tableau non existant entraîne automatiquement sa création.

Variables spéciales

Les variables spéciales suivantes ont une signification particulière pour la commande awk :

Options

Etat de sortie

Cette commande renvoie les valeurs de sortie suivantes :

Exemples

1. Pour afficher les lignes d'un fichier qui excèdent 72 caractères, entrez :

   awk  'length  >72'  chapitre1

   Cette commande sélectionne chaque ligne du fichier chapitre1 qui excède 72 caractères et les écrit sur la sortie standard, car aucune action n'est définie. Un caractère de tabulation a une valeur d'un octet.

2. Pour afficher toutes les lignes qui séparent les mots start et stop, y compris "start" et "stop", entrez :

   awk  '/start/,/stop/'  chapitre1

3. Pour exécuter un programme de la commande awk, sum2.awk, qui traite le fichier chapitre1, entrez :

   awk  -f  sum2.awk  chapitre1

   Le programme suivant, sum2.awk, calcule la somme et la moyenne des nombres de la deuxième colonne du fichier en entrée, chapitre1 :

       {
          sum += $2
       }
   END {
          print "Sum: ", sum;
          print "Average:", sum/NR;
       }

   La première action ajoute la valeur de la deuxième zone de chaque ligne à la variable sum. Toutes les variables sont réglées sur la valeur numérique zéro (0) lorsqu'elles sont référencées pour la première fois. Le modèle END placé avant la deuxième action entraîne l'exécution de ces actions après la lecture entière du fichier en entrée. La variable spéciale NR, utilisée pour calculer la moyenne, définit le nombre d'enregistrements lus.

4. Pour imprimer les deux premières zones dans un ordre inversé, entrez :

   awk '{ print $2, $1 }' chapitre1

5. Le programme awk suivant

   awk -f sum3.awk chapitre2
   

   imprime les deux premières zones du fichier chapitre2, les zones d'entrée étant séparées par une virgule et/ou des blancs et des tabulations, puis calcule la somme des valeurs de la première colonne et imprime la somme et la moyenne :

   BEGIN  {FS = ",|[ \t]+"}
          {print $1, $2}
          {s += $1}
   END    {print "sum is",s,"average is", s/NR }               

Rubriques connexes

Commandes grep et sed.