awk.txt

       
   AWK  
       

awk '[RANGE] [{         #Syntaxe dans un script .sh. Les ; après COMMANDE...
    COMMANDE...         #sont possibles mais inutiles.
}]...' [FILE]...        #Exécute l'ensemble des [RANGE] { COMMANDE... }...,
                        #input par input, dans les [FILE]... concaténés, si
                        #l'input fait partie de [RANGE]
                        #[FILE]... par défaut est stdin : on peut donc rediriger
                        #son input
                        #Si [{ COMMANDE... }] omis mais un RANGE est là,
                        # { print $0 } par défaut

[RANGE] {
    COMMANDE...
}...                    #Syntaxe dans un script .awk. Même chose pour les ;

awk '[RANGE] {
COMMANDE;... }...'
[FILE]...               #Syntaxe en console. Ne pas oublier les ;

awk '{ COMMANDE }
{ COMMANDE }... '
[FILE]...               #Syntaxe correcte, mais à déprécier

awk -f "SCRIPT1"
[FILE]...
awk --file "SCRIPT1"    #Trois syntaxes pour exécuter un script .awk sur
[FILE]...               #[FILE]... Les deux premières contraignent à ajouter un
"SCRIPT2" [FILE]        #shebang

                               LES SCRIPTS .AWK

#!/bin/awk -f           #Si la forme "SCRIPT2" [FILE]... est utilisée, il faut
#!/usr/bin/awk -f       #rajouter #!/bin/awk -f en première ligne
                        #/bin/awk ou /usr/bin/awk en fonction des OS

#Commentaires           #Commentaires

GETTEXT ==>             #Cf gettext

                                    OPTIONS

-F "DELIMITEUR"
--field-separator
"DELIMITEUR"            #Modifie le FS par "DELIMITEUR"
-v "VAR=VALEUR"
--assign "VAR=VALEUR"   #Permet de passer une variable à l'intérieur de awk

                                   PROCESSUS

PROCESSUS  ==>          #1) La concaténation de [FILE]... est divisée en input
                        #   en fonction du RS (par défaut, newline. Input =
                        #   ligne par conséquent)
                        #2) Chaque input est divisé en field en fonction du FS
                        #   (par défaut blanks).
                        #3) Chaque input est exécuté par COMMANDE... s'il est
                        #   contenu dans [RANGE]. Les outputs sont donc triés en
                        #   fonction de leur ordre d'input et non l'ordre des
                        #   blocs { COMMANDE... } dans awk lui-même. Des
                        #   COMMANDE... dans un BEGIN seront par exemple ainsi
                        #   toujours imprimées en premier, même si le bloc BEGIN
                        #   est placé à la fin.

                                   GUILLEMETS

GUILLEMETS ==>          #Les simples guillemets principales n'échappent pas le
                        #déréfencement de $FIELD ou VAR et sont donc purement
                        #syntaxique avec awk.
                        #Le role d'échappement est tenu par les doubles
                        #guillemets à l'interieur des simples guillemets
                        #Les simples guillemets sont interdites dans un script

                           BRACKETS ET HORS-BRACKETS

BRACKETS ==>            #Tout ce qui suit concerne { COMMANDE... } et est donc
                        #toujours entouré de brackets.
HORS-BRACKETS ==>       #Toute commande hors brackets est considérée comme
                        #nulle, sauf si elle contient un nombre ou une chaine "
                        #" non vide, auquel cas elle équivalera à print $0
                        #(pq ?...)

                                     RANGE

[RANGE] {               #Les COMMANDE... ne sont executées que si l'input
    COMMANDE...         #courant est contenu dans [RANGE]. Attention, les
}                       #outputs sont triés en fonction de l'étape 3 du
                        #PROCESSUS (voir PROCESSUS)
                        #
                        #Voici les RANGE possibles :

( TEST )                #L'input courant doit répondre au TEST. Par exemple,
TEST                    #( /PATTERN/ ) { COMMANDE... } exécute COMMANDE...
                        #seulement sur les inputs contenant /PATTERN/
TEST1, TEST2            #L'input courant doit être compris entre deux inputs
                        #répondant respectivement à TEST1 et TEST2 (compris)

TEST || TEST2
TEST && TEST2
! TEST                  #Les opérations booléennes sont possibles

NR == NOMBRE            #désigne donc la ligne numéro NOMBRE
VAR = VAL               #Il est aussi possible d'appliquer des opérations. Par
                        #exemple : NR == NOMBRE, NF = VAL [{ print 0 }]
                        #affichera les fields 1 à VAL de la ligne NOMBRE.

BEGIN                   #S'exécute avant tout input. $0 sera vide
END                     #S'exécute après tous les inputs. Les blocs BEGIN et END
                        #sont importants. $0 sera égal au $0 de la dernière
                        #ligne

                                     FIELDS

$n                      #Renvoie le énième field pour la ligne courante.
                        #Si n est out of range, renvoie espace.
                        #Si n n'est pas un nombre, renvoie $0, et empêche print
                        #d'imprimer ORS.
                        #Les fields peuvent être modifiés ou ajoutés
$0                      #Renvoie la ligne telle quelle si aucun field n'a été
                        #changé, ou l'ensemble des fields séparés par OFS si un
                        #field a été changé
$NF                     #Renvoie le dernier field
$(NF - 1)               #Renvoie l'avant-dernier field

                                   VARIABLES

VAR                     #Renvoie la valeur de VAR (pas besoin de $VAR. $ n'est
                        #utilisé que pour renvoyer les fields)

PORTEE DES VARIABLES => #Les variables sont locales. Il est impossible de
                        #récupérer des variables (dont built-ins) à
                        #l'intérieur d'un awk ' ' ou d'un script .awk.
                        #Pour en donner, deux moyens :
                        #  - 1) utiliser l'option -v
                        #  - 2) pour inclure une variable telle que $VAR ou les
                        #       véritables argument d'un script .sh, il faut
                        #       refermer les guillemets, puis les rouvrir après
                        #       (Ne marche donc pas pour un script .awk)
                        #       Exemple : awk '{ print '"$var"' }'
                        #       Exemple d'utilisation intéressante : var=1 ;
                        #       awk '{ print $'"$var"' }'

TYPAGE DES VARIABLES => #Les variables sont "non-typées" sur le meme principe
                        #que bash. Cependant, il est préférable d'entourer les
                        #strings de guillemets

                              BUILT-INS VARIABLES

REGEXPS ==>             #Regexps étendues (avec limitations)
SEQUENCES D'ECHAPPEMENT #Caractères d'échappement simples avec backslash
AVEC BACKSLASH ==>      #(devant être échappés avec backslash ou guillemets)
                        #(voir doc). \c et \e ne marchent pas

MODIFICATION ==>        #Les built-ins variables peuvent toutes être modifiées,
                        #et changer le comportement de awk en conséquence

FS                      #Input Field Separator : le caractère ou la suite de
                        #caractères délimitant les fields. Un espace est
                        #compris comme "whitespace". Si FS est une chaine vide,
                        #chaque single character devient un field. Par défaut
                        #FS == whitespace. L'option -F "VALEUR" revient à
                        #changer le FS en début de awk.
OFS                     #Output Field Separator : le caractère ou la suite de
                        #caractères délimitant une suite de VAR, "MESSAGE" ou
                        #$FIELD imprimés par print si séparés par une virgule.
                        #Espace par défaut

RS                      #Input Record Separator : le caractère ou suite de
                        #caractères délimitant chaque input. Newline par
                        #défaut. Si RS = "", RS == blanklines
ORS                     #Output Record Separator : le caractère ou suite de
                        #caractères générés après chaque print. Newline par
                        #défaut.

NF                      #Nombre de fields de l'input courant. $NF renvoie donc
                        #le dernier field. Le modifier permet donc de n'afficher
                        #qu'un certain nombre de fields.
NR                      #Numéro de l'input. S'incrémente à chaque input. Permet
                        #par exemple de désigner des lignes précises. Si
                        #plusieurs [FILE]..., ne s'initialise pas à chaque FILE
FNR                     #Même chose, mais s'initialise à chaque [FILE]...

FIELDWIDTHS             #String de forme "LONGUEUR1 LONGUEUR2..." permettant de
                        #définir les fields non pas en fonction de FS mais en
                        #fonction de nombre de caractères fixes pour chaque
                        #field. Par exemple, "3 3 3" créerait trois fields $1 $2
                        #et $3 de trois caractères pour chaque input, les
                        #caractères excédant n'étant pas pris en compte (il n'y
                        #a pas de $4)

FILENAME                #Nom du [FILE]... de l'input courant, tel que spécifié
                        #dans la ligne de commande
ARGC                    #Nombre de [FILE]... spécifiés, plus un
ARGV                    #Array contenant l'ensemble des [FILE]... spécifiés,
                        #plus "awk" à l'index 1.
ARGIND                  #Renvoie l'index dans ARGV du [FILE]... courant.
                        #ARGV[ARGIND] est donc toujours == FILENAME.

RSTART                  #Renvoie l'index renvoyé par le dernier match()
RLENGTH                 #Renvoie la longueur du PATTERN utilisé par le dernier
                        #match() si celui-ci n'a pas échoué, sinon -1

IGNORECASE              #Par défaut 0, mais si initialisé à 1, les /PATTERN/
                        #ignorent la casse.

ENVIRON                 #Associative ARRAY contenant les environment variables
                        #courantes

                                     ARRAYS

ARRAY[INDEX]            #Renvoie la valeur de ARRAY à l'index INDEX. Les indexs
                        #commencent à 1 et non 0
ARRAY[INDEX] = VALEUR   #Décalaration d'arrays

delete ARRAY[INDEX]
delete ARRAY            #Supprime une valeur d'ARRAY ou un ARRAY

ASSOCIATIVE ARRAYS ==>  #Les indexs peuvent être des strings (associative
                        #arrays)
                        #Exemple d'utilisation : s'il faut compter le nombre
                        #d'occurence d'une valeur pour un field précis (par
                        #exemple les propriétaires des fichiers d'un répertoire
                        #grâce à ls), on peut faire : ARRAY[$3]++ pour créer une
                        #ARRAY associative avec le nombre d'occurences. Vérifier
                        #alors que $3 existe bien avant de faire
                        #l'incrémentation

MULTI-DIMENSIONNAL
ARRAYS ==>              #Il faut utiliser une virgule : par exemple, ARR[1,5,3]

                             OPÉRATIONS CLASSIQUES

VAR = VALEUR            #Déclaration de variable
VALEUR VALEUR           #Renvoie la concaténation VALEURVALEUR (ceci peut être
                        #déroutant parfois)

                            OPÉRATIONS ARITHMÉTIQUES

INTERPRÉTATION DE      #  - Si VAR est un nombre, pas de problème.
VAR  ==>                #  - Si VAR ne commence pas par un nombre (exemple :
                        #    string), sera considéré comme 0.
                        #  - Si VAR par un nombre puis continue sur des non-
                        #    nombres, seuls les premiers nombres sont retenus

VAR + VAR
VAR - VAR
VAR * VAR
VAR / VAR
VAR % VAR               #Opérations basiques
(OPERATIONS ARITHM)     #Parenthèses arithmétiques

-VAR                    #Renvoie la valeur négative de VAR

VAR++
++VAR
VAR--
--VAR                   #incrémente et décrémente VAR puis renvoie le résultat.

VAR1 += VAR
VAR1 -= VAR
VAR1 *= VAR
VAR1 /= VAR             #Effectue l'opération, modifie VAR1 puis renvoie le
VAR1 %= VAR             #résultat


                                     TESTS

VALEUR BOOLEENNE ==>    #Il renvoie un 1 pour vrai, 0 pour faux

( VALEUR == VALEUR )
( VALEUR != VALEUR )
( VALEUR < VALEUR )
( VALEUR <= VALEUR )
( VALEUR > VALEUR )
( VALEUR >= VALEUR )    #Tests d'égalité et de comparaison

( VALEUR ~ /PATTERN/ )  #Match ou ne match pas le pattern. Regexps étendues,
( VALEUR !~ /PATTERN/ ) #avec limitations
( /PATTERN/ )           #/PATTERN/ est présent dans l'input courant

                             OPÉRATIONS BOOLÉENNES

VALEUR BOOLEENNE ==>    #Les deux VALEURS testées doivent en théorie être 1 ou
                        #0 (vrai ou faux) mais s'il s'agit d'une autre VALEUR,
                        #elle être interprétée comme un 1. Renvoie un 1 ou un 0.

VALEUR && VALEUR        #Et booléen
VALEUR || VALEUR        #Ou booléen
!VALEUR
!(VALEUR)               #Négation booléenne (préférer la deuxième syntaxe)

                            STRUCTURES DE COMMANDES

if ( TEST ) COMMANDE
if ( TEST ) {
    COMMANDE...
}
if ( TEST ) {
    COMMANDE...
}
else {
    COMMANDE...
}

while ( TEST ) COMMANDE
while ( TEST ) {
    COMMANDE...
}

for ( VAR in ARRAY )
for ( VAR = VALEUR ;
VAR <= VALEUR ;
VAR++ )                 #Ou n'importe quoi du meme acabit

break                   #comme pour bash (sauf que break finit l'itération en
continue                #cours dans un while) et peuvent être utilisés dans une
                        #boucle while ou for

                                   FONCTIONS

function NAME (         #Définit une fonction. Les arguments passés à la
[VAR1][,VARn]...) {     #fonction peuvent être utilisés sous le nom [VARn] dans
    COMMANDE...         #la fonction.
}                       #La fonction doit être définie à l'extérieur d'un bloc
                        #de brackets (idéalement, juste après le bloc BEGIN)

                                  REDIRECTIONS

> "FILE"                #Redirige la sortie vers "FILE" (écrase). Attention, si
                        #>> a déjà utilisé par awk pour ce "FILE", > sera
                        #toujours interprété comme un >> (bug)
>> "FILE"               #Redirige la sortie vers "FILE" (append)

                                   COMMANDES

print VALEUR            #imprime VALEUR puis ORS (par défaut newline), VALEUR
                        #pouvant être VAR, "MESSAGE" ou $FIELD. Toujours mettre
                        #des guillemets autour de "MESSAGE"

print                   #Sans argument, signifie print $0

print VAL1 VAL2         #Imprime VAL1VAL2 concaténés
print VAL1,VAL2         #Imprime VAL1 et VAL2, séparés par OFS

printf("FORMAT"         #Imprime "FORMAT". Attention : n'imprime pas ORS, il
[,ARGUMENT...])         #faut donc spécifié "\n". Les séquences d'échappements
                        #backslash sont possibles. Cependant, \c et \e ne
                        #fonctionnent pas.
                        #Ne pas oublier les guillemets dans "FORMAT"
                        #Les VAR et $FIELD doivent interrompre temporairement
                        #les doubles guillemets pour fonctionner.
                        #
                        #Il est possible d'utiliser des séquences
                        #d'échappements avec pourcentage :
                        #
                        #  - %c     Caractère ASCII
                        #  - %s     String
                        #  - %d     Nombre entier
                        #  - %f     Nombre décimal
                        #  - %e     Nombre décimal avec engineering format
                        #  - %g     Shorter of %e and %f, without trailing zeros
                        #  - %x     Hexadécimal
                        #  - %o     Octal
                        #  - %%     % littéral
                        #
                        #La séquence est alors remplacée par ARGUMENT, en
                        #fonction de la séquence choisie. Si plusieurs
                        #séquences, plusieurs ARGUMENT... doivent être spécifiés
                        #
                        #Il est possible de rajouter des champs entre le % et la
                        #lettre d'une telle séquence :
                        #    %[-][0][TAILLE].[PRECISION]lettre
                        #TAILLE est un nombre spécifiant le nombre minimal de
                        #caractères de la séquence. Si la séquence est plus
                        #petite, des espaces sont ajoutés à gauche.
                        #Des zéros sont ajoutés au lieu des espaces si 0 est
                        #spécifié.
                        #Les espaces sont ajoutés à droite si - est spécifié
                        #PRECISION indique pour :
                        #  - %c     Inutile
                        #  - %s     Le nombre maximal de caractères
                        #  - %d     Le nombre minimal de chiffres. Si la
                        #  - %x     séquence est plus petite, des zéros sont
                        #  - %o     ajoutés à gauche. Peut être combinés avec
                        #  - %g     un padding avec espace grâce à TAILLE.
                        #  - %f     Nombre de chiffres après la virgule. 6 par
                        #  - %e     défaut (voir OFMT)

print... | "COMMANDE"   #Il est possible de piper un print ou printf avec une
printf... | "COMMANDE"  #COMMANDE bash ou unix à l'intérieur même de awk. La
                        #COMMANDE sera exécuté sur tous les outputs du print ou
                        #printf une fois ces derniers exécutés, et non un par un

exit                    #Arrete la commande awk

                              COMMANDES NUMERIQUES

int(NOMBRE)             #Tronque un NOMBRE. Ajouter 0.5 et tronquer revient à
                        #l'arrondir

rand(NOMBRE)            #Génère un nombre pseudo-aléatoire entre 0 et 1 en
                        #fonction de la dernière seed
srand(NOMBRE)           #Génère une nouvelle seed en utilisant le time courant
                        #(la seed change toutes les secondes seulement)

cos(NOMBRE)             #Cosinus
sin(NOMBRE)             #Sinus
atan2(NOMBRE)           #Arc tangente

sqrt(NOMBRE)            #Racine carré
exp(NOMBRE)             #Exponentiel
log(NOMBRE)             #Logarithme

                      COMMANDES DE MANIPULATION DE STRINGS

INDEX ==>               #Les index commencent à 1 et non 0.

length(STRING)          #Renvoie le nombre de caractères de STRING
index(STRING1,STRING2)  #Renvoie l'emplacement de la première occurence de
                        #STRING2 à l'intérieur de STRING1. Renvoie 0 si aucune
                        #occurence.
match(STRING,/PATTERN/) #Même chose mais peut utiliser une regexp étendue (avec
                        #limitation). La variable RSTART enregistre également ce
                        #qui est renvoyé. Si échec, RLENGTH == -1, sinon,
                        #RLENGTH == longueur de PATTERN
substr(STRING,DEBUT     #Renvoie les LONGUEUR caractères contenu à partir de
[,LONGUEUR])            #l'index DEBUT dans STRING. Si LONGUEUR n'est pas
                        #spécifié, renvoie le maximum de caractères.
split(STRING,ARRAY,     #Remplace ARRAY par une array consitituée du dépeçage
"DELIMITEUR")           #de STRING en fonction de "DELIMITEUR". Renvoie le
                        #nombre d'éléments d'ARRAY

sub(/OLD/,"NEW"         #Remplace la première occurence d'OLD (regexp étendue
[,STRING])              #avec limitations) par NEW dans STRING. Renvoie 1 si
                        #occurence trouvée, 0 sinon. STRING est $0 par défaut.
                        #\1...\9, \0 et & sont utilisables comme pour sed s///
gsub(/OLD/,"NEW"        #Comme sub mais remplace toutes les occurence. Renvoie
[,STRING])              #le nombre d'occurences trouvées.
gensub(/OLD/,"NEW",     #Comme sub, mais ne remplace pas l'occurence, la renvoie
"FLAG"[,STRING])        #seulement. FLAG peut être g ou un nombre, comme pour
                        #sed s///. FLAG est obligatoire, mettre "" si aucun
                        #FLAG désiré.

toupper(STRING)         #Renvoie STRING uppercase
tolower(STRING)         #Renvoie STRING lowercase

                       COMMANDES DE MANIPULATION D'ARRAYS

asort(ARRAY1[,ARRAY2])  #Trie ARRAY1 et renvoie le nombre d'éléments d'ARRAY1.
                        #Si ARRAY2 est spécifié, ARRAY1 reste tel quel, et le
                        #résultat après le tri est copié dans ARRAY2

                                AUTRES COMMANDES

system("COMMANDES")     #Exécute $(COMMANDES) et renvoie l'exit code (0
                        #signifiant true #et 1 false, contrairement aux tests
                        #awk)
getline [VAR]           #Passe à l'input suivant, tout en continuant le bloc
                        #{ COMMANDE... } courant. Enregistre le nouvel input
                        #dans VAR si spécifié.
next                    #Même chose mais ne continue pas le bloc { COMMANDE... }

strftime("DATE1"        #Affiche la date courante en fonction des séquences
[,DATE2])               #d'échappements pour date (voir doc) spécifiées dans
                        #DATE1.
                        #Séquences d'échappement backslash possibles ainsi que
                        #strings normales.
                        #Si DATE2 spécifiée (nombre de secondes depuis 1970
                        #uniquement), elle est utilisée à la place de la date
                        #courante.
systime()               #Affiche le nombre de secondes depuis le 1er janvier
                        #1970