Notions de base la programmation de Awk
Awk — dont le nom vient des trois créateurs, Alfred Aho, Peter Weinberger et Brian Kernighan — est un langage de traitement de lignes, disponible sur la plupart des systèmes Unix et Linux. Il est principalement utilisé pour la manipulation de fichiers textuels pour des opérations de recherches, de remplacement et de transformations complexes.
Awk a été introduit avec la version 7 UNIX en 1979, et une version mise à jour appelée «nawk» a été introduit avec la version 3.1 du système 5 UNIX en 1985. Ces versions originales sont parfois appelé le Seul Vrai Awk (The One True Awk). La dernière version de ce code source est disponible à l'adresse: http://www.cs.princeton.edu/~bwk/btl.mirror/.
GNU Awk «gawk» met en œuvre toutes les fonctionnalités POSIX 1003.1 standard (http://pubs.opengroup.org/onlinepubs/9699919799/utilities/awk.html) et certaines autres caractéristiques intéressantes comme «switch».
Sortie
Voici comment on peut sortir du texte à l'écran, ou en informatique STDOUT (sortie standard).
#!/bin/awk -f BEGIN { print "Hello" }
Variables
En informatique, les variables sont un nom symbolique associé à une valeur et dont la valeur associée peut être changé. En Bourne Shell, il n'y a pas de type de donnée pour les variable.
#!/bin/awk -f BEGIN { num = 5 char= "a" string = "This is a string" print "Number is " num print "Character is '" char "'" print "String is \"" string "\"" }
Arithmétique
Le shell POSIX supporte les opérations arithmétiques avec des nombres entiers: $(( expression mathématique ))
#!/bin/awk -f BEGIN { width = 5 len = 6 area = width * len print "The area of a square (width=" width ", length=" len ") is " area true = 1 false = 0 result = true && false || true print "The statement (true AND false OR true) is " result }
Pour l'arithmétique à virgule flottante, utilisez la commande bc.
#!/bin/awk -f BEGIN { pi = 3.1415927 radius = 3 area = pi * radius^2 print "The area of a circle with a radius of 3 is: " area }
Le résultat avec GNU bc (à partir de Cygwin 1.7.15 sur Windows NT 6.1) est: 28,2743343
Certaines fonctions mathématiques sont pris en charge par l'outil awk:
Certaines fonctions mathématiques sont pris en charge par l'outil awk:
#!/bin/awk -f BEGIN { pi = 3.1415927 print "The cosine of pi/4 is: " cos(pi/4) }
La précision avec awk est de 6 chiffres, donc la réponse est 0,707107.
Entrée
C'est la façon d'obtenir la saisie au clavier, ou en informatique STDIN (entrée standard).
#!/bin/awk -f BEGIN { printf "Enter a name: " getline name print "Hello " name }
Choix
La branche est un point où un flux logiciel est modifié. Essentiellement, le logiciel choisit un chemin après l'évaluation d'un test.
Voici une section simple qui utilise «test» pour évaluer un certain nombre:
Voici une section simple qui utilise «test» pour évaluer un certain nombre:
#!/bin/awk -f BEGIN { printf "Input a number: " getline number if (number > 0) print "Number is greater than 0" else if (number < 0) print "Number is less than 0" else print "Number is 0" }
La construction de «case» permettra de comparer une chaîne à un motif. Si le motif trouve une correspondance, un bloc de code est exécuté.
Pour «case», l'environnement du shell gère les modèles appelés un modèle «glob». Cet modèle «glob» est une syntaxe qui représente par un ensemble de chaînes.
Pour «case», l'environnement du shell gère les modèles appelés un modèle «glob». Cet modèle «glob» est une syntaxe qui représente par un ensemble de chaînes.
#!/bin/gawk -f BEGIN { printf "Input a character: " getline keypress switch (keypress) { case /[[:lower:]]/: print "Lowercase letter" break case /[[:upper:]]/: print "Uppercase letter" break case /[[:digit:]]/: print "Digit" break default: print "Punctuation, whitespace, or other" } }
En utilisant la construction de «if», le test pour le motif de «case» peut être créé en utilisant cette méthode:
#!/bin/awk -f BEGIN { printf "Input a character: " getline keypress if (keypress ~ /[[:lower:]]/) print "Lowercase letter" else if (keypress ~ /[[:upper:]]/) print "Uppercase letter" else if (keypress ~ /[[:digit:]]/) print "Digit" else print "Punctuation, whitespace, or other" }
Boucles
Une boucle est une séquence d'instructions qui est spécifié une fois mais qui peut être réalisée plusieurs fois de suite.
Il y a une boucle commandée par un compter. Cette boucle compte de 10 à 1.
Il y a une boucle commandée par un compter. Cette boucle compte de 10 à 1.
#!/bin/awk -f BEGIN { # count loop using for for ( count = 10; count > 0; count-- ) print "count is " count }
Il y a une boucle commandée par un état. L'utilisateur de déterminer l'état. Lorsque l'utilisateur tape "quit" la boucle se termine.
#!/bin/awk -f BEGIN { do { printf "Enter your name (quit to exit): " getline answer if (answer != "quit") print "Hello " answer } while ( answer != "quit" ) }
Il y a une boucle commandée par un ensemble d'éléments (collection). Cet exemple exécute un sous-shell pour exécuter une commande. La sortie de cette sous-shell sera divisé en éléments. Ces éléments peuvent alors être traitées dans chaque itération de la boucle.
#!/bin/awk -f BEGIN { while ("ls -l" | getline) { if (/^d/) print $9 " is a directory" else print $9 " is a not a directory" } }
Tableaux
Le shell Bourne ne prend pas en charge les tableaux. Cette fonctionnalité peut être émulé avec chaînes séparées par des espaces.
#!/bin/awk -f # Join (array, sep) - returns string given array and seperator # Helper function to help enumerate a list easily function join(array, sep) { result = array[0] end = length(array) for (i = 1; i <= end; i++) { sep = (i == end) ? "" : sep result = result sep array[i] } return result } BEGIN { nicknames[0]="bob" nicknames[1]="ed" nicknames[2]="steve" nicknames[3]="ralph" nicknames[4]="joe" nicknames[5]="deb" nicknames[6]="kate" # print number of elements print "The number of nicknames is: " length(nicknames) # print all of elements in one line printf "The nicknames are: " join(nicknames, ", ") "\n" }
#!/bin/awk -f BEGIN { # build array # Note: awk doesn't have mechanism to build array in one line # Thus, we use split function as a workaround for this limitation split("bob ed steve ralph joe deb kate", nicknames) # print out array item by item print "The names are: " for (name in nicknames) print " " nicknames[name] }
Tableaux associatifs
Le shell Bourne ne prend pas en charge les tableaux associatif.
#!/bin/awk -f BEGIN { # individually build array ages["bob"]=34 ages["ed"]=58 ages["steve"]=32 ages["ralph"]=23 ages["deb"]=46 ages["kate"]=19 # print all key indexes # Note: awk has no mechanism to enumerate all keys, # so we must loop through array printf "Keys (names): " for (key in ages) printf key " " printf "\n" # print all values # Note: awk has no mechanism to enumerate all values, # so we must loop through array printf "Values (ages): " for (key in ages) printf ages[key] " " printf "\n" }
Fonction
Une fonction est une portion de code représentant un sous-programme qui effectue une tâche et qui renvoie une valeur. Dans l'environnement du shell, la fonction n'a pas vraiment retourner une valeur. Au lieu de cela, elle renvoie un code de sortie, qui est lu par le variable $?.
#!/bin/awk -f function show_date() { "date" | getline date # fetch date split(date, items) # split up date # output results printf "Today is %s %s %s.\n", items[2], items[3], items[4] } BEGIN { show_date() }
Arguments (Paramètres positionnels)
Un système d'exploitation prend en charge la fonctionnalité pour envoyer des paramètres (appelés options ou «flags») à un programme. Ils sont également appelés arguments de la ligne de commande. L'environnement du shell utilise les paramètres positionnels pour traiter ces arguments en ligne de commande.
Un paramètre de position est représentée par une variable ordinale particulière comme $1, $2, $3, et ainsi de suite. Le nombre maximum d'arguments envoyés au script est représenté par $#. Le script lui-même est appelé $0.
Un paramètre de position est représentée par une variable ordinale particulière comme $1, $2, $3, et ainsi de suite. Le nombre maximum d'arguments envoyés au script est représenté par $#. Le script lui-même est appelé $0.
#!/bin/awk -f BEGIN { if (ARGC == 2) printf "You need to enter two numbers: \"%s\" num1 num2", ARGV[0] else printf "The sum of %d and %d is: %d", ARGV[1], ARGV[2], ARGV[1] + ARGV[2] }
Voici une méthode pour lister les arguments. La commande «shift» est utilisée pour changer la position des paramètres. Lorsque «shift» est utilisé, tous les paramètres seront décalées vers le haut. Ainsi, «$3» deviendra «$2», «$2» deviendra «$1» et «$1» sera effacé. Comme cela se produit, la variable «$#» décrémente.
#!/bin/awk -f BEGIN { print "The arugments passed are:" for (count = 1; count < ARGC; count++) { printf " item %d: %s\n", count, ARGV[count] } }
Dans une autre méthode pour lister les arguments, nous pouvons utiliser explicitement un certain nombre. Pour cela, il faudra utiliser la commande «eval».
#!/bin/awk -f BEGIN { print "The arugments passed are (reverse order):" for (count = ARGC; count > 0; count--) { printf " item %d: %s\n", count, ARGV[count] } }
Paramètres des fonctions
Dans l'environnement du shell, les paramètres positionnels sont utilisés pour contenir les paramètres passés à une fonction. Ils fonctionnent exactement de la même manière que les arguments de ligne de commande.
#!/bin/awk -f function add(nums) { sum = 0 # initalize to 0 for (num in nums) { sum += num } # add all nums in array print "The summation is: " sum # output results } BEGIN { # build dynamic list of params param_str = "5 2 4 3 6" # declare string of params split(param_str, param_list) # make into array of params # call the function add(param_list) # pass array of dynamic params }