LIBOF

Manuels pour la ligne de commande

Man » Manuel awk en ligne - documentation en ligne détaillée pour la page de manuel awk

🌍 ☰ 
gawk - langage de balayage et de traitement de motifs

SYNTAXE

gawk [options de style POSIX ou GNU] -f fichier-programme [ -- ] fichier ...
gawk [options de style POSIX ou GNU] [ -- ] texte-programme fichier ...

LISEZ CECI D'ABORD

Cette page de manuel est fournie à titre de courtoisie. Veuillez noter que la source d'information unique pour gawk est le manuel Texinfo, disponible en ligne dans différents formats à l'adresse https://www.gnu.org/software/gawk/manual. Il peut également être installé dans le sous-système Info de votre système et être accessible via la commande info(1).

En cas de contradiction entre le manuel Texinfo et cette page de manuel, le manuel doit être considéré comme faisant autorité.

DESCRIPTION

Gawk est l'implémentation du langage de programmation AWK du projet GNU. Il est conforme à la définition du langage dans la norme POSIX 1003.1. Cette version est à son tour basée sur la description de The AWK Programming Language, par Aho, Kernighan et Weinberger. Gawk fournit les fonctionnalités supplémentaires présentes dans la version actuelle d'awk de Brian Kernighan et de nombreuses extensions spécifiques à GNU.

La ligne de commande est composée d'options pour gawk lui-même, du texte du programme AWK (si ce n'est pas fourni via les options -f ou --include), et des valeurs qui doivent être mises à disposition dans les variables AWK prédéfinies ARGC et ARGV.

PRÉFACE

Cette page de manuel est intentionnellement aussi concise que possible. Les détails complets sont fournis dans GAWK : Effective AWK Programming, et vous devriez vous y référer pour obtenir l'histoire complète de toute fonctionnalité spécifique. Dans la mesure du possible, des liens vers la version en ligne du manuel sont fournis.

FORMAT DES OPTIONS

Les options de Gawk peuvent être soit les options traditionnelles de style POSIX à une seule lettre, soit les options longues de style GNU. Les options POSIX commencent par un seul « - », tandis que les options longues commencent par « -- ». Les options longues sont fournies pour les fonctionnalités spécifiques à GNU et pour les fonctionnalités imposées par POSIX.

Les options spécifiques à Gawk sont généralement utilisées sous forme d'options longues. Les arguments des options longues sont soit joints à l'option par un signe =, sans espace intermédiaire, soit ils peuvent être fournis dans l'argument de ligne de commande suivant. Les options longues peuvent être abrégées, à condition que l'abréviation reste unique.

De plus, chaque option longue possède une option courte correspondante, de sorte que la fonctionnalité de l'option puisse être utilisée dans les scripts exécutables #!.

OPTIONS

Gawk accepte les options suivantes. Les options standard sont répertoriées en premier, suivies des options pour les extensions gawk, répertoriées par ordre alphabétique de l'option courte.

-f fichier-programme, --file fichier-programme

Lisez la source du programme AWK à partir du fichier fichier-programme, au lieu du premier argument de ligne de commande. Plusieurs options -f peuvent être utilisées. Les fichiers lus avec -f sont traités comme s'ils commençaient par une instruction @namespace "awk" implicite.

-F fs, --field-separator fs
Utilise fs pour le séparateur de champs d’entrée (la valeur de la variable prédéfinie FS).

-v var=val, --assign var=val
Attribue la valeur val à la variable var, avant le début de l’exécution du programme. Ces valeurs de variables sont disponibles pour la règle BEGIN d’un programme AWK.

-b, --characters-as-bytes
Traite toutes les données d’entrée comme des caractères à un octet. L’option --posix annule cette option.

-c, --traditional
Exécute en mode de compatibilité. En mode de compatibilité, gawk se comporte de la même manière que awk de Brian Kernighan ; aucune des extensions spécifiques à GNU n’est reconnue.

-C, --copyright
Affiche la version courte du message d’information sur le droit d’auteur GNU sur la sortie standard et se termine avec succès.

-d[file], --dump-variables[=file]
Affiche une liste triée des variables globales, de leurs types et de leurs valeurs finales dans un fichier. Le fichier par défaut est awkvars.out dans le répertoire courant.

-D[file], --debug[=file]
Active le débogage des programmes AWK. Par défaut, le débogueur lit les commandes de manière interactive à partir du clavier (entrée standard). L’argument de fichier facultatif spécifie un fichier contenant une liste de commandes que le débogueur doit exécuter de manière non interactive.
Dans ce mode d’exécution, gawk charge le code source du programme AWK, puis invite à entrer des commandes de débogage. Gawk ne peut déboguer que le code source du programme AWK fourni avec les options -f et --include. Le débogueur est documenté dans GAWK : Effective AWK Programming ; voir https://www.gnu.org/software/gawk/manual/html_node/Debugger.html#Debugger.

-e program-text, --source program-text
Utilise program-text comme code source du programme AWK. Chaque argument fourni via -e est traité comme s’il commençait par une instruction implicite @namespace "awk".

-E file, --exec file
Similaire à -f, cependant, cette option est la dernière à être traitée. Elle doit être utilisée avec les scripts #!, en particulier pour les applications CGI, afin d’éviter de transmettre des options ou du code source sur la ligne de commande à partir d’une URL. Cette option désactive les affectations de variables en ligne de commande.

-g, --gen-pot
Analyse et traite le programme AWK, et génère un fichier au format GNU .pot (Portable Object Template) sur la sortie standard avec des entrées pour toutes les chaînes localisables du programme. Le programme lui-même n’est pas exécuté.

-h, --help
Affiche un bref résumé des options disponibles sur la sortie standard. Conformément aux normes de codage GNU, ces options provoquent une sortie réussie immédiate.

-i include-file, --include include-file
Charge une bibliothèque de code source awk. Cela recherche la bibliothèque en utilisant la variable d’environnement AWKPATH. Si la première recherche échoue, une autre tentative est effectuée après l’ajout du suffixe .awk. Le fichier ne sera chargé qu’une seule fois (c’est-à-dire que les doublons sont éliminés), et le code ne constitue pas le code source du programme principal. Les fichiers lus avec --include sont traités comme s’ils commençaient par une instruction implicite @namespace "awk".

-I, --trace
Affiche les noms internes des instructions du bytecode lorsqu’elles sont exécutées pendant l’exécution du programme. La trace est imprimée sur la sortie d’erreur standard. Chaque « opcode » est précédé d’un signe « + » dans la sortie.

-k, --csv
Active le traitement spécial CSV. Voir « Valeurs séparées par des virgules », ci-dessous, pour plus de détails.

-l lib, --load lib
Charge une extension gawk à partir de la bibliothèque partagée lib. Cela recherche la bibliothèque en utilisant la variable d’environnement AWKLIBPATH. Si la première recherche échoue, une autre tentative sera effectuée après avoir ajouté le suffixe de bibliothèque partagée par défaut pour la plateforme. La routine d’initialisation de la bibliothèque doit être nommée dl_load().

-L [valeur], --lint[=valeur]
Fournit des avertissements concernant les constructions qui sont douteuses ou non portables vers d’autres implémentations AWK. Voir https://www.gnu.org/software/gawk/manual/html\_node/Options.html\#Options pour la liste des valeurs possibles pour valeur.

-M, --bignum
Force l’utilisation d’une arithmétique de précision arbitraire pour les nombres. Cette option n’a aucun effet si gawk n’est pas compilé pour utiliser les bibliothèques GNU MPFR et GMP. (Dans ce cas, gawk émet un avertissement.)

REMARQUE : cette fonctionnalité est en période d’essai. Le principal responsable de gawk ne la prend plus en charge, bien qu’il existe un membre de l’équipe de développement qui le fasse. Si cette situation change, la fonctionnalité sera supprimée de gawk.

-n, --non-decimal-data
Reconnaît les valeurs octales et hexadécimales dans les données d’entrée. Utilisez cette option avec une extrême prudence !

-N, --use-lc-numeric
Force gawk à utiliser le caractère séparateur décimal de la locale lors de l’analyse des données d’entrée.

-o[fichier], --pretty-print[=fichier]
Affiche une version formatée du programme dans un fichier. Le fichier par défaut est awkprof.out dans le répertoire courant. Cette option implique --no-optimize.

-O, --optimize
Active les optimisations par défaut de gawk sur la représentation interne du programme. Cette option est activée par défaut.

-p[fichier-profil], --profile[=fichier-profil]
Démarre une session de profilage et envoie les données de profilage au fichier fichier-profil. La valeur par défaut est awkprof.out dans le répertoire courant. Le profil contient les nombres d’exécution de chaque instruction du programme dans la marge gauche et les nombres d’appels de fonction pour chaque fonction définie par l’utilisateur. Gawk fonctionne plus lentement dans ce mode. Cette option implique --no-optimize.

-P, --posix
Cela active le mode de compatibilité et désactive un certain nombre d’extensions courantes.

-r, --re-interval
Active l’utilisation d’expressions d’intervalle dans la correspondance d’expressions régulières. Les expressions d’intervalle sont activées par défaut, mais cette option reste pour assurer la compatibilité avec les versions antérieures.

-s, --no-optimize
Désactive les optimisations par défaut de gawk sur la représentation interne du programme.

-S, --sandbox
Exécute gawk en mode sandbox, désactivant la fonction system(), la redirection d’entrée avec getline, la redirection de sortie avec print et printf, et le chargement d’extensions dynamiques. L’exécution de commandes (via des pipelines) est également désactivée.

-t, --lint-old
Affiche des avertissements concernant les constructions qui ne sont pas compatibles avec la version originale d’UNIX
awk.

-V, --version
Affiche les informations de version de cette copie spécifique de gawk sur la sortie standard. Cela
est utile pour signaler des bogues. Conformément aux normes de codage GNU, ces options provoquent une sortie réussie immédiate.

--
Signale la fin des options. Ceci est utile pour permettre aux arguments supplémentaires du programme AWK
de commencer par un « - ».

En mode de compatibilité, toutes les autres options sont signalées comme invalides, mais sont sinon ignorées. En fonctionnement normal, tant que du texte de programme a été fourni, les options inconnues sont transmises au programme AWK dans le tableau ARGV pour traitement.

Pour la compatibilité POSIX, l’option -W peut être utilisée, suivie du nom d’une option longue.

EXÉCUTION DU PROGRAMME AWK

Un programme AWK est constitué d’une séquence de directives optionnelles, d’instructions de motif-action et de définitions de fonctions optionnelles.

@include "nom_de_fichier"
@load "nom_de_fichier"
@namespace "nom"
motif { instructions d’action }
fonction nom(liste de paramètres) { instructions }

Gawk lit d’abord le code source du programme à partir des fichiers de programme spécifiés, des arguments de --source, ou du premier argument non option sur la ligne de commande. Les options -f et --source peuvent être utilisées plusieurs fois sur la ligne de commande. Gawk lit le texte du programme comme si tous les fichiers de programme et les textes sources de la ligne de commande avaient été concaténés.

De plus, les lignes commençant par @include peuvent être utilisées pour inclure d’autres fichiers sources dans votre programme. Ceci est équivalent à l’utilisation de l’option --include.

Les lignes commençant par @load peuvent être utilisées pour charger des fonctions d’extension dans votre programme. Ceci est équivalent à l’utilisation de l’option --load.

La variable d’environnement AWKPATH spécifie un chemin de recherche à utiliser lors de la recherche de fichiers sources mentionnés dans les options -f et --include. Si cette variable n’existe pas, le chemin par défaut est ".:/usr/local/share/awk". (Le répertoire réel peut varier en fonction de la façon dont gawk a été compilé et installé.) Si un nom de fichier donné à l’option -f contient un caractère « / », aucune recherche de chemin n’est effectuée.

La variable d’environnement AWKLIBPATH spécifie un chemin de recherche à utiliser lors de la recherche de fichiers sources mentionnés dans l’option --load. Si cette variable n’existe pas, le chemin par défaut est "/usr/local/lib/gawk". (Le répertoire réel peut varier en fonction de la façon dont gawk a été compilé et installé.)

Gawk exécute les programmes AWK dans l’ordre suivant. Tout d’abord, toutes les affectations de variables spécifiées via l’option -v sont effectuées. Ensuite, gawk compile le programme dans une forme interne. Ensuite, gawk exécute le code dans les règles BEGIN (le cas échéant), puis procède à la lecture de chaque fichier mentionné dans le tableau ARGV (jusqu’à ARGV[ARGC-1]). S’il n’y a pas de fichiers mentionnés sur la ligne de commande, gawk lit l’entrée standard.

Si un nom de fichier sur la ligne de commande a la forme var=val, il est traité comme une affectation de variable. La variable var sera affectée à la valeur val. (Cela se produit après l’exécution de toutes les règles BEGIN.)

Si la valeur d’un élément particulier de ARGV est vide (""), gawk l’ignore.

Pour chaque fichier d’entrée, si une règle BEGINFILE existe, gawk exécute le code associé avant de traiter le contenu du fichier. De même, gawk exécute le code associé aux règles ENDFILE après avoir traité le fichier.

Pour chaque enregistrement dans l’entrée, gawk vérifie si l’enregistrement correspond à l’un des motifs du programme AWK. Pour chaque motif auquel l’enregistrement correspond, gawk exécute l’action associée. Les motifs sont testés dans l’ordre dans lequel ils apparaissent dans le programme.

Enfin, une fois que toute l’entrée a été traitée, gawk exécute le code de la ou des règles END (si elles existent).

Répertoires en ligne de commande

Selon POSIX, les fichiers nommés dans la commande awk doivent être des fichiers texte. Le comportement est « indéfini » s’ils ne le sont pas. La plupart des versions d’awk considèrent qu’un répertoire en ligne de commande est une erreur fatale.

Pour gawk, un répertoire en ligne de commande génère un avertissement, mais est sinon ignoré. Si l’une ou l’autre des options --posix ou --traditional est donnée, gawk revient à considérer les répertoires en ligne de commande comme une erreur fatale.

VARIABLES, ENREGISTREMENTS ET CHAMPS

Les variables AWK sont dynamiques ; elles entrent en existence lorsqu’elles sont utilisées pour la première fois. Leurs valeurs sont soit des nombres à virgule flottante, soit des chaînes de caractères, soit les deux, selon la façon dont elles sont utilisées. De plus, gawk permet aux variables d’avoir un type d’expression régulière. AWK dispose également de tableaux à une dimension ; les tableaux à plusieurs dimensions peuvent être simulés. Cependant, gawk fournit de vrais tableaux de tableaux. Plusieurs variables prédéfinies sont définies au fur et à mesure de l’exécution d’un programme ; elles sont décrites au besoin et résumées ci-dessous.

Enregistrements

Normalement, les enregistrements sont séparés par des caractères de saut de ligne. Vous pouvez contrôler la façon dont les enregistrements sont séparés en attribuant des valeurs à la variable intégrée RS. Voir https://www.gnu.org/software/gawk/manual/html_node/Records.html pour plus de détails.

Champs

Au fur et à mesure que chaque enregistrement d’entrée est lu, gawk divise l’enregistrement en champs, en utilisant la valeur de la variable FS comme séparateur de champs. De plus, FIELDWIDTHS et FPAT peuvent être utilisés pour contrôler la division des champs d’entrée. Voir les détails, à partir de https://www.gnu.org/software/gawk/manual/html_node/Fields.html.

Chaque champ dans l’enregistrement d’entrée peut être référencé par sa position : $1, $2, etc. $0 est l’ensemble de l’enregistrement, y compris les espaces de début et de fin.

La variable NF est définie sur le nombre total de champs dans l’enregistrement d’entrée.

Les références à des champs inexistants (c’est-à-dire les champs après $NF) produisent une chaîne vide. Cependant, l’affectation à un champ inexistant (par exemple, $(NF+2) = 5) augmente la valeur de NF, crée tous les champs intermédiaires avec une chaîne vide comme valeur et fait que la valeur de $0 est recalculée, les champs étant séparés par la valeur de OFS. Les références à des champs numérotés négativement entraînent une erreur fatale. La décrémentation de NF fait perdre les valeurs des champs après la nouvelle valeur, et la valeur de $0 est recalculée, les champs étant séparés par la valeur de OFS.

L’assignation d’une valeur à un champ existant entraîne la reconstruction de l’ensemble de l’enregistrement lorsque $0 est référencé. De même, l’assignation d’une valeur à $0 entraîne la division de l’enregistrement, ce qui crée de nouvelles valeurs pour les champs.

Valeurs séparées par des virgules

Lorsqu’il est appelé avec l’option -k ou --csv, gawk n’utilise pas la détermination régulière des enregistrements et la division des champs comme décrit ci-dessus. Au lieu de cela, les enregistrements sont terminés par des nouvelles lignes non entre guillemets, et les champs sont séparés par des virgules. Les guillemets peuvent être utilisés pour inclure des champs contenant des virgules, des nouvelles lignes ou des guillemets doubles. Voir [https://www.gnu.org/software/gawk/manual/html_node/Comma-Separated-Fields.html] pour plus de détails.

Variables intégrées

Les variables intégrées de Gawk sont répertoriées ci-dessous. Cette liste est intentionnellement concise. Pour plus de détails, voir [https://www.gnu.org/software/gawk/manual/html_node/Built_002din-Variables.html].

ARGC        Le nombre d’arguments de ligne de commande.

ARGIND      L’index dans ARGV du fichier actuel en cours de traitement.

ARGV        Tableau des arguments de ligne de commande. Le tableau est indexé de 0 à ARGC - 1.

BINMODE     Sur les systèmes non POSIX, spécifie l’utilisation du mode « binaire » pour toutes les opérations d’E/S de fichiers. Voir [https://www.gnu.org/software/gawk/manual/html\_node/PC-Using.html](https://www.gnu.org/software/gawk/manual/html_node/PC-Using.html) pour plus de détails.

CONVFMT     Le format de conversion pour les nombres, « %.6g » par défaut.

ENVIRON     Un tableau contenant les valeurs de l’environnement actuel. Le tableau est indexé par les variables d’environnement, chaque élément étant la valeur de cette variable.

ERRNO       Si une erreur système se produit lors d’une redirection pour getline, pendant une lecture pour getline ou pendant une fermeture, ERRNO est défini sur une chaîne décrivant l’erreur. La valeur est sujette à traduction dans les locales non anglaises.

FIELDWIDTHS Une liste de largeurs de champs séparées par des espaces. Lorsqu’elle est définie, gawk analyse l’entrée en champs de largeur fixe, au lieu d’utiliser la valeur de la variable FS comme séparateur de champs. Chaque largeur de champ peut être précédée d’une valeur séparée par deux points spécifiant le nombre de caractères à ignorer avant le début du champ.

FILENAME    Le nom du fichier d’entrée actuel. Si aucun fichier n’est spécifié sur la ligne de commande, la valeur de FILENAME est « - ». Cependant, FILENAME n’est pas défini dans la règle BEGIN (à moins qu’il ne soit défini par getline).

FNR         Le numéro d’enregistrement d’entrée dans le fichier d’entrée actuel.

FPAT        Une expression régulière décrivant le contenu des champs d’un enregistrement. Lorsqu’elle est définie, gawk analyse l’entrée en champs, où les champs correspondent à l’expression régulière, au lieu d’utiliser la valeur de FS comme séparateur de champs.

FS          Le séparateur de champs d’entrée, un espace par défaut. Voir [https://www.gnu.org/software/gawk/manual/html\_node/Field-Separators.html] pour plus de détails.

FUNCTAB     Un tableau dont les indices et les valeurs correspondantes sont les noms de toutes les fonctions définies par l'utilisateur ou d'extension dans le programme. REMARQUE : vous ne pouvez pas utiliser l'instruction delete avec le tableau FUNCTAB.

IGNORECASE  Contrôle la sensibilité à la casse de toutes les opérations de chaînes et d'expressions régulières. Voir https://www.gnu.org/software/gawk/manual/html_node/Case_002dsensitivity.html pour plus de détails.

LINT        Fournit un contrôle dynamique de l'option --lint à partir d'un programme AWK.

NF          Le nombre de champs dans l'enregistrement d'entrée actuel.

NR          Le nombre total d'enregistrements d'entrée vus jusqu'à présent.

OFMT        Le format de sortie pour les nombres, "%.6g" par défaut.

OFS         Le séparateur de champs de sortie, un espace par défaut.

ORS         Le séparateur d'enregistrements de sortie, une nouvelle ligne par défaut.

PREC        La précision de travail des nombres à virgule flottante de précision arbitraire, 53 par défaut.

PROCINFO    Les éléments de ce tableau permettent d'accéder aux informations sur le programme AWK en cours d'exécution. Voir https://www.gnu.org/software/gawk/manual/html_node/Auto_002dset pour plus de détails.

ROUNDMODE   Le mode d'arrondi à utiliser pour l'arithmétique de nombres de précision arbitraire, par défaut "N" (mode IEEE-754 roundTiesToEven). Voir https://www.gnu.org/software/gawk/manual/html_node/Setting-the-rounding-mode pour plus de détails.

RS          Le séparateur d'enregistrements d'entrée, une nouvelle ligne par défaut.

RT          Le terminateur d'enregistrement. Gawk définit RT sur le texte d'entrée qui correspond au caractère ou à l'expression régulière spécifié par RS.

RSTART      L'index du premier caractère correspondant à match() ; 0 s'il n'y a pas de correspondance.

RLENGTH     La longueur de la chaîne correspondant à match() ; -1 s'il n'y a pas de correspondance.

SUBSEP      La chaîne utilisée pour séparer les multiples sous-indices dans les éléments de tableau, par défaut "\034".

SYMTAB      Un tableau dont les indices sont les noms de toutes les variables et tableaux globaux actuellement définis dans le programme. Vous ne pouvez pas utiliser l'instruction delete avec le tableau SYMTAB, ni affecter des valeurs aux éléments dont l'index n'est pas un nom de variable.

TEXTDOMAIN  Le domaine de texte du programme AWK ; utilisé pour trouver les traductions localisées des chaînes du programme.

Tableaux

Les tableaux sont indexés par une expression entre crochets ([ et ]). Si l'expression est une liste d'expressions (expr, expr ...), l'index du tableau est une chaîne composée de la concaténation de la valeur (chaîne) de chaque expression, séparées par la valeur de la variable SUBSEP. Cette fonctionnalité est utilisée pour simuler des tableaux à plusieurs dimensions. Par exemple :

i = "A"; j = "B"; k = "C"
x[i, j, k] = "hello, world\n"

affecte la chaîne "hello, world\n" à l'élément du tableau x qui est indexé par la chaîne "A\034B\034C". Tous les tableaux dans AWK sont associatifs, c'est-à-dire indexés par des valeurs de chaîne.

L'opérateur spécial in peut être utilisé pour tester si un tableau a un index composé d'une valeur particulière :

if (val in array)
    print array[val]

Si le tableau a plusieurs indices, utilisez (i, j) dans array.

La construction « in » peut également être utilisée dans une boucle « for » pour parcourir tous les éléments d’un tableau. Cependant, la construction « (i, j) in array » ne fonctionne que dans les tests, pas dans les boucles « for ».

Un élément peut être supprimé d’un tableau à l’aide de l’instruction « delete ». L’instruction « delete » peut également être utilisée pour supprimer tout le contenu d’un tableau en spécifiant simplement le nom du tableau sans indice.

gawk prend en charge les tableaux multidimensionnels réels. Il n’est pas nécessaire que ces tableaux soient « rectangulaires », comme en C ou C++. Voir [https://www.gnu.org/software/gawk/manual/html_node/Arrays] pour plus de détails.

Espaces de noms

Gawk fournit une fonction d’espace de noms simple pour aider à contourner le fait que toutes les variables en AWK sont globales.

Un nom qualifié se compose de deux identificateurs simples joints par deux points (::). L’identificateur de gauche représente l’espace de noms et l’identificateur de droite est la variable dans cet espace de noms. Tous les noms simples (non qualifiés) sont considérés comme se trouvant dans l’« espace de noms actuel » ; l’espace de noms par défaut est awk. Cependant, les identificateurs simples composés uniquement de lettres majuscules sont placés de force dans l’espace de noms awk, même si l’espace de noms actuel est différent.

Vous pouvez modifier l’espace de noms actuel à l’aide de la directive « @namespace « nom » ».

Les noms des fonctions intégrées prédéfinies standard ne peuvent pas être utilisés comme noms d’espace de noms. Les noms des fonctions supplémentaires fournies par gawk peuvent être utilisés comme noms d’espace de noms ou comme identificateurs simples dans d’autres espaces de noms. Pour plus de détails, voir [https://www.gnu.org/software/gawk/manual/html_node/Namespaces.html#Namespaces].

Typage et conversion des variables

Les variables et les champs peuvent être des nombres (à virgule flottante), des chaînes de caractères ou les deux. Ils peuvent également être des expressions régulières. La manière dont la valeur d’une variable est interprétée dépend de son contexte. Si elle est utilisée dans une expression numérique, elle sera traitée comme un nombre ; si elle est utilisée comme une chaîne de caractères, elle sera traitée comme une chaîne de caractères.

Pour forcer une variable à être traitée comme un nombre, ajoutez zéro à celle-ci ; pour la forcer à être traitée comme une chaîne de caractères, concaténez-la avec la chaîne nulle.

Les variables non initialisées ont la valeur numérique zéro et la valeur de chaîne « » (la chaîne nulle ou vide).

Lorsqu’une chaîne de caractères doit être convertie en nombre, la conversion est effectuée à l’aide de strtod(3). Un nombre est converti en chaîne de caractères en utilisant la valeur de CONVFMT comme chaîne de format pour sprintf(3), avec la valeur numérique de la variable comme argument. Cependant, même si tous les nombres en AWK sont à virgule flottante, les valeurs entières sont toujours converties en entiers.

Gawk effectue des comparaisons de la manière suivante : si deux variables sont numériques, elles sont comparées numériquement. Si une valeur est numérique et que l’autre a une valeur de chaîne qui est une « chaîne numérique », les comparaisons sont également effectuées numériquement. Sinon, la valeur numérique est convertie en chaîne de caractères et une comparaison de chaînes de caractères est effectuée. Deux chaînes de caractères sont bien sûr comparées comme des chaînes de caractères.

Remarquez que les chaînes de caractères, comme « 57 », ne sont pas des chaînes numériques, ce sont des constantes de chaîne. L’idée de « chaîne numérique » ne s’applique qu’aux champs, aux entrées getline, à FILENAME, aux éléments ARGV, aux éléments ENVIRON et aux éléments d’un tableau créé par split() ou patsplit() qui sont des chaînes numériques. L’idée de base est que seules les entrées utilisateur qui ressemblent à des nombres doivent être traitées comme telles.

Constantes octales et hexadécimales

Vous pouvez utiliser des constantes octales et hexadécimales de type C dans le code source de votre programme AWK. Par exemple, la valeur octale 011 est égale à la valeur décimale 9, et la valeur hexadécimale 0x11 est égale à la valeur décimale 17.

Constantes de chaîne

Les constantes de chaîne dans AWK sont des séquences de caractères encadrées par des guillemets doubles (comme « value »). À l’intérieur des chaînes, certaines séquences d’échappement sont reconnues, comme en C. Voir [https://www.gnu.org/software/gawk/manual/html_node/Escape-Sequences] pour plus de détails.

Constantes d’expression régulière

Une constante d’expression régulière est une séquence de caractères encadrée par des barres obliques (comme /value/).

Les séquences d’échappement décrites dans le manuel peuvent également être utilisées à l’intérieur des constantes d’expression régulière (par exemple, /[ \t\f\n\r\v]/ correspond aux caractères d’espacement).

Gawk fournit des constantes d’expression régulière fortement typées. Elles sont précédées du symbole @ (comme ceci : @/value/). Ces constantes peuvent être affectées à des scalaires (variables, éléments de tableau) et transmises à des fonctions définies par l’utilisateur. Les variables auxquelles elles ont été affectées ont un type d’expression régulière.

MOTIFS ET ACTIONS

AWK est un langage orienté ligne. Le motif vient en premier, puis l’action. Les instructions d’action sont encadrées par { et }. Soit le motif peut être manquant, soit l’action peut être manquante, mais pas les deux. Si le motif est manquant, l’action s’exécute pour chaque enregistrement de l’entrée. Une action manquante est équivalente à

{ print }

qui affiche tout l’enregistrement.

Les commentaires commencent par le caractère # et se poursuivent jusqu’à la fin de la ligne. Des lignes vides peuvent être utilisées pour séparer les instructions. Normalement, une instruction se termine par une nouvelle ligne, mais ce n’est pas le cas pour les lignes se terminant par une virgule, {, ?, :, && ou ||. Les lignes se terminant par do ou else ont également leurs instructions automatiquement continues sur la ligne suivante. Dans d’autres cas, une ligne peut être continuée en la terminant par un « \ », auquel cas la nouvelle ligne est ignorée. Cependant, un « \ » après un # n’est pas spécial.

Plusieurs instructions peuvent être placées sur une seule ligne en les séparant par un « ; ». Cela s’applique à la fois aux instructions à l’intérieur de la partie action d’une paire motif-action (le cas habituel), et aux instructions motif-action elles-mêmes.

Motifs

Les motifs AWK peuvent être l’un des suivants :

BEGIN
END
BEGINFILE
ENDFILE
/expression régulière/
expression relationnelle
motif && motif
motif || motif
motif ? motif : motif
(motif)
! motif
motif1, motif2

BEGIN et END sont deux types spéciaux de motifs qui ne sont pas testés par rapport à l’entrée. Les parties d’action de tous les motifs BEGIN sont fusionnées comme si toutes les instructions avaient été écrites dans une seule règle BEGIN. Elles sont exécutées avant que toute entrée ne soit lue. De même, toutes les règles END sont fusionnées et exécutées lorsque toute l’entrée est épuisée (ou lorsqu’une instruction exit est exécutée). Les motifs BEGIN et END ne peuvent pas être combinés avec d’autres motifs dans des expressions de motifs. Les motifs BEGIN et END ne peuvent pas avoir de parties d’action manquantes.

BEGINFILE et ENDFILE sont des motifs spéciaux supplémentaires dont les actions sont exécutées avant de lire le premier enregistrement de chaque fichier d’entrée en ligne de commande et après avoir lu le dernier enregistrement de chaque fichier. À l’intérieur de la règle BEGINFILE, la valeur de ERRNO est une chaîne vide si le fichier a été ouvert avec succès. Sinon, il y a un problème avec le fichier et le code doit utiliser nextfile pour l’ignorer. Si cela n’est pas fait, gawk produit son erreur fatale habituelle pour les fichiers qui ne peuvent pas être ouverts.

Pour les motifs /expression régulière/, l’instruction associée est exécutée pour chaque enregistrement d’entrée qui correspond à l’expression régulière. Les expressions régulières sont essentiellement les mêmes que celles de egrep(1). Voir https://www.gnu.org/software/gawk/manual/html_node/Regexp.html pour plus de détails sur les expressions régulières.

Une expression relationnelle peut utiliser l’un des opérateurs définis ci-dessous dans la section sur les actions. Ceux-ci testent généralement si certains champs correspondent à certaines expressions régulières.

Les opérateurs &&, || et ! sont les opérateurs logique ET, logique OU et logique NON, respectivement, comme en C. Ils effectuent une évaluation à court-circuit, également comme en C, et sont utilisés pour combiner des expressions de motifs plus primitives. Comme dans la plupart des langages, les parenthèses peuvent être utilisées pour modifier l’ordre d’évaluation.

L’opérateur ?: est similaire à cet opérateur en C. Si le premier motif est vrai, le motif utilisé pour le test est le deuxième motif, sinon c’est le troisième. Un seul des deuxième et troisième motifs est évalué.

La forme expression1, expression2 d’une expression est appelée motif de plage. Il correspond à tous les enregistrements d’entrée commençant par un enregistrement qui correspond au motif1, et se poursuivant jusqu’à un enregistrement qui correspond au motif2, inclus. Il ne se combine avec aucun autre type d’expression de motifs.

Actions

Les instructions d’action sont délimitées par des accolades, { et }. Les instructions d’action consistent en les instructions d’affectation, conditionnelles et de bouclage habituelles que l’on trouve dans la plupart des langages. Les opérateurs, les instructions de contrôle et les instructions d’entrée/sortie disponibles sont calqués sur ceux de C.

Opérateurs

Les opérateurs dans AWK, par ordre de précédence décroissante, sont :

(...) Regroupement

$ Référence de champ.

++ -- Incrémentation et décrémentation, préfixe et postfixe.

^ Exponentiation.

+ - ! Unaire plus, unaire moins et négation logique.

* / %       Multiplication, division et modulo.

+ -         Addition et soustraction.

espace      Concaténation de chaînes de caractères.

|   |&      Entrée/sortie par canal pour getline, print et printf.

< > <= >= == !=
Les opérateurs relationnels classiques.

~ !~        Correspondance d’expression régulière, correspondance négée.

in          Appartenance à un tableau.

&&          ET logique.

||          OU logique.

?:          L’expression conditionnelle C. Elle a la forme expr1 ? expr2 : expr3. Si expr1 est vraie, la valeur de l’expression est expr2, sinon elle est expr3. Seule l’une des expressions expr2 et expr3 est évaluée.

= += -= *= /= %= ^=
Affectation. L’affectation absolue (var = valeur) et l’affectation par opérateur (les autres formes) sont prises en charge.

Instructions de contrôle

Les instructions de contrôle sont les suivantes :

if (condition) instruction [ else instruction ]
while (condition) instruction
do instruction while (condition)
for (expr1 ; expr2 ; expr3) instruction
for (var in array) instruction
break
continue
delete array[index]
delete array
exit [ expression ]
{ instructions }
switch (expression) {
case value|regex : instruction
...
[ default: instruction ]
}

Instructions d’entrée/sortie

Les instructions d’entrée/sortie sont les suivantes :

close(file [, how])   Ferme un fichier, un canal ou un coprocesseur ouvert. L’argument facultatif how ne doit être utilisé que lors de la fermeture d’une extrémité d’un canal bidirectionnel vers un coprocesseur. Il doit s’agir d’une valeur de chaîne, soit « to », soit « from ».

getline               Définit $0 sur l’enregistrement d’entrée suivant ; définit NF, NR, FNR, RT.

getline <file         Définit $0 sur l’enregistrement suivant du fichier ; définit NF, RT.

getline var           Définit var sur l’enregistrement d’entrée suivant ; définit NR, FNR, RT.

getline var <file     Définit var sur l’enregistrement suivant du fichier ; définit RT.

command | getline [var]
Exécute command, en redirigeant la sortie vers $0 ou var, comme ci-dessus, et RT.

command |& getline [var]
Exécute command sous forme de coprocesseur en redirigeant la sortie vers $0 ou var, comme ci-dessus, et RT. (La commande peut également être une socket. Voir la section « Noms de fichiers spéciaux » ci-dessous.)

fflush([file])        Vide tous les tampons associés au fichier ou au canal de sortie ouvert. Si file est manquant ou s’il s’agit d’une chaîne vide, vide tous les fichiers et canaux de sortie ouverts.

next                  Arrête le traitement de l’enregistrement d’entrée actuel. Lit l’enregistrement d’entrée suivant et reprend le traitement avec le premier motif du programme AWK. Une fois la fin des données d’entrée atteinte, exécute les règles END.

nextfile              Arrête le traitement du fichier d’entrée actuel. L’enregistrement d’entrée suivant lu provient du fichier d’entrée suivant. Met à jour FILENAME et ARGIND, réinitialise FNR à 1 et reprend le traitement avec le premier motif du programme AWK. Une fois la fin des données d’entrée atteinte, exécute les règles ENDFILE et END.

print                 Affiche l’enregistrement actuel. L’enregistrement de sortie est terminé par la valeur de ORS.

print expr-list       Affiche les expressions. Chaque expression est séparée par la valeur de OFS. L’enregistrement de sortie est terminé par la valeur de ORS.

print expr-list >file Affiche les expressions dans un fichier. Chaque expression est séparée par la valeur de OFS. L'enregistrement de sortie est terminé par la valeur de ORS.

printf fmt, expr-list Formate et affiche.

printf fmt, expr-list >file
Formate et affiche dans un fichier.

system(cmd-line)      Exécute la commande cmd-line et renvoie le code de sortie. (Cela peut ne pas être disponible sur les systèmes non POSIX). Voir https://www.gnu.org/software/gawk/manual/html_node/I_002fO-Functions.html#I_002fO-Functions pour tous les détails sur le code de sortie.

D'autres redirections de sortie sont autorisées pour print et printf.

print ... >> file
Ajoute la sortie au fichier.

print ... | command
Écrit dans un pipe.

print ... |& command
Envoie des données à un coprocesseur ou à une socket. (Voir également la sous-section Noms de fichiers spéciaux, ci-dessous.)

La fonction getline renvoie 1 en cas de succès, 0 en cas de fin de fichier et -1 en cas d'erreur. Si la valeur de errno(3) indique que l'opération d'E/S peut être réessayée et que PROCINFO["input", "RETRY"] est définie, -2 est renvoyé au lieu de -1, et d'autres appels à getline peuvent être tentés. En cas d'erreur, ERRNO est défini sur une chaîne décrivant le problème.

REMARQUE : L'échec de l'ouverture d'une socket bidirectionnelle entraîne une erreur non fatale renvoyée à la fonction appelante. Si vous utilisez un pipe, un coprocesseur ou une socket avec getline, ou à partir de print ou printf dans une boucle, vous devez utiliser close() pour créer de nouvelles instances de la commande ou de la socket. AWK ne ferme pas automatiquement les pipes, les sockets ou les coprocesseurs lorsqu'ils renvoient EOF.

Les versions AWK de l'instruction printf et de la fonction sprintf() sont similaires à celles de C. Pour plus de détails, voir https://www.gnu.org/software/gawk/manual/html_node/Printf.html.

Noms de fichiers spéciaux

Lors de la redirection d'E/S à partir de print ou printf vers un fichier, ou via getline à partir d'un fichier, gawk reconnaît certains noms de fichiers spéciaux en interne. Ces noms de fichiers permettent d'accéder aux descripteurs de fichiers ouverts hérités du processus parent de gawk (généralement le shell). Ces noms de fichiers peuvent également être utilisés sur la ligne de commande pour nommer des fichiers de données. Les noms de fichiers sont :

- Les entrées standard.

/dev/stdin Les entrées standard.

/dev/stdout La sortie standard.

/dev/stderr La sortie d'erreur standard.

/dev/fd/n Le fichier associé au descripteur de fichier ouvert n.

Les noms de fichiers suivants peuvent être utilisés avec l'opérateur de coprocesseur |& pour créer des connexions réseau TCP/IP :

/inet/tcp/lport/rhost/rport
/inet4/tcp/lport/rhost/rport
/inet6/tcp/lport/rhost/rport
Fichiers pour une connexion TCP/IP sur le port local lport vers l'hôte distant rhost sur le port distant rport. Utilisez un port de 0 pour laisser le système choisir un port. Utilisez /inet4 pour forcer une connexion IPv4 et /inet6 pour forcer une connexion IPv6. L'utilisation de /inet utilise la valeur par défaut du système (très probablement IPv4). Utilisable uniquement avec l'opérateur d'E/S bidirectionnel |&.

/inet/udp/lport/rhost/rport
/inet4/udp/lport/rhost/rport
/inet6/udp/lport/rhost/rport
Similaire, mais utilise UDP/IP au lieu de TCP/IP.

Fonctions numériques

AWK possède les fonctions arithmétiques intégrées suivantes :

atan2(y, x)  Retourne l’arctangente de y/x en radians.

cos(expr)  Retourne le cosinus de expr, qui est en radians.

exp(expr)  La fonction exponentielle.

int(expr)  Tronque à un entier.

log(expr)  La fonction logarithme naturel.

rand()  Retourne un nombre aléatoire N, compris entre zéro et un, tel que 0 ≤ N < 1.

sin(expr)  Retourne le sinus de expr, qui est en radians.

sqrt(expr)  Retourne la racine carrée de expr.

srand([expr]) Utilise expr comme nouvelle graine pour le générateur de nombres aléatoires. Si aucun expr n’est fourni, utilise l’heure du jour. Retourne la graine précédente pour le générateur de nombres aléatoires.

Fonctions de chaîne de caractères

Gawk possède les fonctions de chaîne de caractères intégrées suivantes ; les détails sont fournis dans https://www.gnu.org/software/gawk/manual/html_node/String-Functions.

asort(s [, d [, how] ]) Retourne le nombre d’éléments dans le tableau source s. Trie le contenu de s en utilisant les règles de comparaison de valeurs de gawk, et remplace les index des valeurs triées de s par des entiers séquentiels commençant à 1. Si le tableau de destination optionnel d est spécifié, duplique d’abord s dans d, puis trie d, laissant les index du tableau source s inchangés. La chaîne optionnelle how contrôle la direction et le mode de comparaison. Les valeurs valides pour how sont décrites dans https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions. s et d peuvent être le même tableau ; cela n’a de sens que lorsque le troisième argument est également fourni.

asorti(s [, d [, how] ])

Retourne le nombre d’éléments dans le tableau source s. Le comportement est le même que celui de asort(), sauf que les index du tableau sont utilisés pour le tri, et non les valeurs du tableau. Une fois terminé, le tableau est indexé numériquement, et les valeurs sont celles des index d’origine. Les valeurs d’origine sont perdues ; fournissez donc un deuxième tableau si vous souhaitez conserver les valeurs d’origine. Le but de la chaîne optionnelle how est le même que pour asort(). Ici aussi, s et d peuvent être le même tableau ; cela n’a de sens que lorsque le troisième argument est également fourni.

gensub(r, s, h [, t]) Recherche dans la chaîne cible t les correspondances de l’expression régulière r. Si h est une chaîne commençant par g ou G, remplace alors toutes les correspondances de r par s. Sinon, h est un nombre indiquant quelle correspondance de r remplacer. Si t n’est pas fourni, utilise $0 à la place. Dans le texte de remplacement s, la séquence \n, où n est un chiffre de 1 à 9, peut être utilisée pour indiquer uniquement le texte qui correspond à la n-ième sous-expression entre parenthèses. La séquence \0 représente l’ensemble du texte correspondant, tout comme le caractère &. Contrairement à sub() et gsub(), la chaîne modifiée est renvoyée comme résultat de la fonction, et la chaîne cible d’origine n’est pas modifiée.


`gsub(r, s [, t])` Pour chaque sous-chaîne correspondant à l'expression régulière `r` dans la chaîne `t`, substituez la chaîne `s` et renvoyez le nombre de substitutions. Si `t` n'est pas fourni, utilisez `$0`. Un `&` dans le texte de remplacement est remplacé par le texte qui a été réellement trouvé. Utilisez `\&` pour obtenir un `&` littéral. (Cela doit être tapé comme `"\\&"`; voir [https://www.gnu.org/software/gawk/manual/html_node/Gory-Details.html#Gory-Details] pour une discussion plus complète des règles concernant les esperluettes et les barres obliques inverses dans le texte de remplacement de `sub()`, `gsub()` et `gensub()`.)

`index(s, t)` Renvoie l'index de la chaîne `t` dans la chaîne `s`, ou zéro si `t` n'est pas présent. (Cela implique que les index de caractères commencent à un.)

`length([s])` Renvoie la longueur de la chaîne `s`, ou la longueur de `$0` si `s` n'est pas fourni. Avec un argument de type tableau, `length()` renvoie le nombre d'éléments dans le tableau.

`match(s, r [, a])` Renvoie la position dans `s` où l'expression régulière `r` se trouve, ou zéro si `r` n'est pas présente, et définit les valeurs de `RSTART` et `RLENGTH`. Notez que l'ordre des arguments est le même que pour l'opérateur `~`: `str ~ re`. Voir [https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions] pour une description de la manière dont le tableau `a` est rempli s'il est fourni.

`patsplit(s, a [, r [, seps] ])` Divise la chaîne `s` en un tableau `a` et un tableau de séparateurs `seps` en utilisant l'expression régulière `r`, et renvoie le nombre de champs. Les valeurs des éléments sont les portions de `s` qui correspondent à `r`. La valeur de `seps[i]` est le séparateur, éventuellement nul, qui est apparu après `a[i]`. La valeur de `seps[0]` est le séparateur, éventuellement nul, qui précède. Si `r` est omis, `FPAT` est utilisé à la place. Les tableaux `a` et `seps` sont d'abord effacés. La division se comporte de manière identique à la division de champs avec `FPAT`.

`split(s, a [, r [, seps] ])` Divise la chaîne `s` en un tableau `a` et un tableau de séparateurs `seps` en utilisant l'expression régulière `r`, et renvoie le nombre de champs. Si `r` est omis, `FS` est utilisé à la place. Les tableaux `a` et `seps` sont d'abord effacés. `seps[i]` est le séparateur de champ correspondant à `r` entre `a[i]` et `a[i+1]`. La division se comporte de manière identique à la division de champs.

`sprintf(fmt, expr-list)` Imprime `expr-list` selon `fmt`, et renvoie la chaîne résultante.

`strtonum(str)` Examine `str` et renvoie sa valeur numérique. Si `str` commence par un `0` en tête, traitez-le comme un nombre octal. Si `str` commence par un `0x` ou `0X` en tête, traitez-le comme un nombre hexadécimal. Sinon, supposez que c'est un nombre décimal.

`sub(r, s [, t])` Exactement comme `gsub()`, mais remplace uniquement la première sous-chaîne correspondante. Renvoie soit zéro, soit un.

`substr(s, i [, n])` Renvoie la sous-chaîne de `s` commençant à `i` et contenant au plus `n` caractères. Si `n` est omis, utilisez le reste de `s`.

`tolower(str)` Renvoie une copie de la chaîne `str`, avec toutes les lettres majuscules de `str` traduites en leurs équivalents minuscules. Les caractères non alphabétiques sont laissés inchangés.

`toupper(str)` Renvoie une copie de la chaîne `str`, avec toutes les lettres minuscules de `str` traduites en leurs équivalents majuscules. Les caractères non alphabétiques sont laissés inchangés.

Gawk prend en charge le multibyte. Cela signifie que les fonctions index(), length(), substr() et match() fonctionnent en termes de caractères et non d'octets.

Fonctions de temps

Gawk fournit les fonctions suivantes pour obtenir des horodatages et les formater. Les détails sont disponibles à l'adresse https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.

mktime(datespec [, utc-flag])

Convertit datespec en un horodatage du même format que celui renvoyé par systime() et renvoie le résultat. Si utc-flag est présent et est différent de zéro ou non nul, l'heure est supposée être dans le fuseau horaire UTC ; sinon, l'heure est supposée être dans le fuseau horaire local. Si datespec ne contient pas suffisamment d'éléments ou si l'heure résultante est hors limites, mktime() renvoie -1. Voir https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.html#Time-Functions pour les détails de datespec.

strftime([format [, timestamp[, utc-flag]]])

Formate timestamp selon la spécification dans format. Si utc-flag est présent et est différent de zéro ou non nul, le résultat est en UTC, sinon le résultat est en heure locale. L'horodatage doit être du même format que celui renvoyé par systime(). Si timestamp est manquant, l'heure actuelle est utilisée. Si format est manquant, un format par défaut équivalent à la sortie de date(1) est utilisé. Le format par défaut est disponible dans PROCINFO["strftime"]. Voir la spécification de la fonction strftime() en ISO C pour les conversions de format garanties.

systime() Renvoie l'heure actuelle sous forme de nombre de secondes depuis l'époque (1er janvier 1970, 00h00 UTC sur les systèmes POSIX).

Fonctions de manipulation de bits

Gawk fournit les fonctions de manipulation de bits suivantes. Elles fonctionnent en convertissant les valeurs à virgule flottante double précision en entiers uintmax_t, en effectuant l'opération, puis en reconvertissant le résultat en une valeur à virgule flottante. Le passage d'opérandes négatifs à l'une de ces fonctions provoque une erreur fatale.

Les fonctions sont les suivantes :

and(v1, v2 [, ...]) Renvoie le résultat de l'opération OU logique sur les valeurs fournies dans la liste des arguments. Il doit y avoir au moins deux valeurs.

compl(val) Renvoie le complément binaire de `val`.

lshift(val, count) Renvoie la valeur de `val` décalée de `count` bits vers la gauche.

or(v1, v2 [, ...]) Renvoie le résultat de l'opération OU logique sur les valeurs fournies dans la liste des arguments. Il doit y avoir au moins deux valeurs.

rshift(val, count) Renvoie la valeur de `val` décalée de `count` bits vers la droite.

xor(v1, v2 [, ...]) Renvoie le résultat de l'opération OU exclusif sur les valeurs fournies dans la liste des arguments. Il doit y avoir au moins deux valeurs.

Fonctions de type

Les fonctions suivantes fournissent des informations sur le type de leurs arguments.

isarray(x) Renvoie `true` si `x` est un tableau, `false` sinon.

typeof(x) Renvoie une chaîne indiquant le type de `x`. La chaîne sera l'une des suivantes : "array", "number", "regexp", "string", "strnum", "unassigned" ou "undefined".

Fonctions d’internationalisation

Les fonctions suivantes peuvent être utilisées dans votre programme AWK pour traduire des chaînes de caractères pendant l’exécution. Pour plus de détails, consultez le site https://www.gnu.org/software/gawk/manual/html_node/I18N-Functions.html#I18N-Functions.

bindtextdomain(directory [, domain])

Spécifie le répertoire dans lequel gawk recherche les fichiers .gmo, au cas où ils ne seraient pas ou ne pourraient pas être placés dans les « emplacements standard ». Elle renvoie le répertoire où le domaine est « lié ». Le domaine par défaut est la valeur de TEXTDOMAIN. Si directory est une chaîne vide (""), bindtextdomain() renvoie le paramètre actuel pour le domaine donné.

dcgettext(string [, domain [, category]])
Renvoie la traduction de string dans le domaine de texte domain pour la catégorie de locale category. La valeur par défaut de domain est la valeur actuelle de TEXTDOMAIN. La valeur par défaut de category est "LC_MESSAGES".

dcngettext(string1, string2, number [, domain [, category]])

Renvoie la forme plurielle utilisée pour le nombre de la traduction de string1 et string2 dans le domaine de texte domain pour la catégorie de locale category. La valeur par défaut de domain est la valeur actuelle de TEXTDOMAIN. La valeur par défaut de category est "LC_MESSAGES".

Fonctions à valeur booléenne

Vous pouvez créer des valeurs spéciales de type booléen ; consultez le manuel pour savoir comment elles fonctionnent et pourquoi elles existent.

mkbool(expression)

En fonction de la valeur booléenne de expression, renvoie une valeur vraie ou une valeur fausse. Les valeurs vraies ont une valeur numérique de un. Les valeurs fausses ont une valeur numérique de zéro.

FONCTIONS DÉFINIES PAR L’UTILISATEUR

Les fonctions dans AWK sont définies comme suit :

function name(liste de paramètres) { instructions }

Les fonctions sont exécutées lorsqu’elles sont appelées dans les expressions, soit dans les motifs, soit dans les actions. Les paramètres réels fournis dans l’appel de fonction sont utilisés pour instancier les paramètres formels déclarés dans la fonction. Les tableaux sont passés par référence, les autres variables sont passées par valeur.

Les variables locales sont déclarées sous forme de paramètres supplémentaires dans la liste des paramètres. La convention consiste à séparer les variables locales des paramètres réels par des espaces supplémentaires dans la liste des paramètres. Par exemple :

function f(p, q,     a, b) # a et b sont des variables locales
{
...
}

/abc/     { ... ; f(1, 2) ; ... }

La parenthèse gauche dans un appel de fonction doit immédiatement suivre le nom de la fonction, sans espace intermédiaire. Cette restriction ne s’applique pas aux fonctions intégrées répertoriées ci-dessus.

Les fonctions peuvent s’appeler mutuellement et peuvent être récursives. Les paramètres de fonction utilisés comme variables locales sont initialisés à la chaîne vide et au nombre zéro lors de l’invocation de la fonction.

Utilisez return expr pour renvoyer une valeur d’une fonction. La valeur de retour est indéfinie si aucune valeur n’est fournie, ou si la fonction renvoie en « sortant » à la fin.

Les fonctions peuvent être appelées indirectement. Pour ce faire, affectez le nom de la fonction à appeler, sous forme de chaîne de caractères, à une variable. Utilisez ensuite la variable comme s’il s’agissait du nom de la fonction, précédée du signe @, comme suit : function myfunc() { print "myfunc called" ... }

{    ...
the_func = "myfunc"
@the_func()    # appel via the_func à myfunc
...
}

Si l'option --lint est fournie, gawk affiche un avertissement concernant les appels à des fonctions non définies au moment de l'analyse syntaxique, au lieu de le faire au moment de l'exécution. L'appel à une fonction non définie au moment de l'exécution est une erreur fatale.

CHARGEMENT DYNAMIQUE DE NOUVELLES FONCTIONS

Vous pouvez ajouter dynamiquement de nouvelles fonctions écrites en C ou C++ à l'interpréteur gawk en cours d'exécution à l'aide de l'instruction @load. Les détails complets dépassent la portée de cette page du manuel ; voir https://www.gnu.org/software/gawk/manual/html_node/Dynamic-Extensions.html#Dynamic-Extensions.

SIGNALS

Le profileur gawk accepte deux signaux. SIGUSR1 lui fait afficher un profil et la pile d'appels de fonctions dans le fichier de profil, qui est soit awkprof.out, soit le fichier nommé avec l'option --profile. Il continue ensuite à s'exécuter. SIGHUP fait que gawk affiche le profil et la pile d'appels de fonctions, puis se termine.

INTERNATIONALISATION

Les constantes de chaîne sont des séquences de caractères délimitées par des guillemets doubles. Dans les environnements non anglophones, il est possible de marquer les chaînes dans le programme AWK comme nécessitant une traduction dans la langue naturelle locale. Ces chaînes sont marquées dans le programme AWK avec un soulignement en tête (« _ »). Par exemple,

gawk 'BEGIN { print "hello, world" }'

affiche toujours hello, world. Mais,

gawk 'BEGIN { print _"hello, world" }'

pourrait afficher bonjour, monde en France. Voir https://www.gnu.org/software/gawk/manual/html_node/Internationalization.html#Internationalization pour les étapes à suivre pour créer et exécuter un programme AWK localisable.

EXTENSIONS GNU

Gawk a un trop grand nombre d'extensions à POSIX awk. Elles sont décrites dans https://www.gnu.org/software/gawk/manual/html_node/POSIX_002fGNU.html. Toutes les extensions peuvent être désactivées en invoquant gawk avec les options --traditional ou --posix.

VARIABLES D'ENVIRONNEMENT

La variable d'environnement AWKPATH peut être utilisée pour fournir une liste de répertoires dans lesquels gawk effectue une recherche lorsqu'il recherche des fichiers nommés via les options -f, --file, -i et --include, et la directive @include. Si la recherche initiale échoue, le chemin est recherché à nouveau après avoir ajouté .awk au nom de fichier.

La variable d'environnement AWKLIBPATH peut être utilisée pour fournir une liste de répertoires dans lesquels gawk effectue une recherche lorsqu'il recherche des fichiers nommés via les options -l et --load.

La variable d'environnement GAWK_PERSIST_FILE, si elle est présente, spécifie un fichier à utiliser comme magasin de stockage pour la mémoire persistante. Voir GAWK : Effective AWK Programming pour les détails.

La variable d'environnement GAWK_READ_TIMEOUT peut être utilisée pour spécifier un délai d'attente en millisecondes pour la lecture des entrées à partir d'un terminal, d'un tube ou d'une communication bidirectionnelle, y compris les sockets.


Pour la connexion à un hôte distant via un socket, GAWK_SOCK_RETRIES contrôle le nombre de tentatives, et
GAWK_MSEC_SLEEP l’intervalle entre les tentatives. L’intervalle est en millisecondes. Sur les systèmes qui
ne prennent pas en charge usleep(3), la valeur est arrondie au nombre entier de secondes supérieur.

Si POSIXLY_CORRECT existe dans l’environnement, alors gawk se comporte exactement comme si l’option --posix
avait été spécifiée sur la ligne de commande. Si --lint a été spécifiée, gawk affiche un message d’avertissement à
cet effet.

STATUT DE SORTIE

Si l’instruction exit est utilisée avec une valeur, alors gawk quitte avec la valeur numérique donnée.

Autrement, s’il n’y a eu aucun problème pendant l’exécution, gawk quitte avec la valeur de la constante C EXIT_SUCCESS. Il s’agit généralement de zéro.

Si une erreur se produit, gawk quitte avec la valeur de la constante C EXIT_FAILURE. Il s’agit généralement de un.

Si gawk quitte en raison d’une erreur fatale, le statut de sortie est 2. Sur les systèmes non POSIX, cette valeur peut être mappée à EXIT_FAILURE.

INFORMATIONS SUR LA VERSION

Cette page de manuel documente gawk, version 5.3.

AUTEURS

La version originale d’UNIX awk a été conçue et implémentée par Alfred Aho, Peter Weinberger et Brian Kernighan de Bell Laboratories. Ozan Yigit est l’actuel responsable. Brian Kernighan participe occasionnellement à son développement.

Paul Rubin et Jay Fenlason, de la Free Software Foundation, ont écrit gawk pour qu’il soit compatible avec la version originale d’awk distribuée dans UNIX, septième édition. John Woods a apporté un certain nombre de corrections de bogues. David Trueman, avec les contributions d’Arnold Robbins, a rendu gawk compatible avec la nouvelle version d’UNIX awk. Arnold Robbins est l’actuel responsable.

Consultez GAWK : Effective AWK Programming pour obtenir la liste complète des contributeurs à gawk et à sa documentation.

Consultez le fichier README dans la distribution gawk pour obtenir des informations à jour sur les responsables et les ports actuellement pris en charge.

RAPPORTS DE BOGUE ET QUESTIONS

Si vous trouvez un bogue dans gawk, veuillez utiliser le programme gawkbug(1) pour le signaler.

Des instructions complètes sur la façon de signaler un bogue sont fournies dans https://www.gnu.org/software/gawk/manual/html_node/Bugs.html. Veuillez lire attentivement et suivre les instructions données. Cela facilitera le signalement et la résolution des bogues pour toutes les personnes concernées. Vraiment.

D’autre part, si vous avez une question sur la façon d’accomplir une tâche particulière en utilisant awk ou gawk, envoyez un e-mail à _ avec votre demande d’aide.

BOGUES

L’option -F n’est pas nécessaire étant donné la fonctionnalité d’affectation de variables de la ligne de commande ; elle est conservée uniquement pour assurer la compatibilité avec les versions antérieures.

Cette page de manuel est trop longue ; gawk a trop de fonctionnalités.

CONSULTER AUSSI

egrep(1), sed(1), gawkbug(1), printf(3) et strftime(3).

The AWK Programming Language, deuxième édition, Alfred V. Aho, Brian W. Kernighan, Peter J. Weinberger, Addison-Wesley, 2023. ISBN 9-780138-269722.

GAWK : Effective AWK Programming, édition 5.3, fournie avec le code source de gawk. La version actuelle
de ce document est disponible en ligne à l’adresse https://www.gnu.org/software/gawk/manual.

La documentation de GNU gettext est disponible en ligne à l'adresse https://www.gnu.org/software/gettext.

EXEMPLES

Afficher et trier les noms d'utilisateur de tous les utilisateurs :

BEGIN     { FS = ":" }
{ print $1 | "sort" }

Compter le nombre de lignes dans un fichier :

{ nlines++ }
END  { print nlines }

Ajouter le numéro de ligne de chaque ligne en tête de ligne :

{ print FNR, $0 }

Concaténer et ajouter un numéro de ligne (une variation sur le thème) :

{ print NR, $0 }

Exécuter une commande externe pour des lignes de données spécifiques :

tail -f access_log |
awk '/myhome.html/ { system("nmap " $1 ">> logdir/myhome.html") }'

PERMISSIONS DE COPIE

Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005 2007, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 2024, 2025 Free Software Foundation, Inc.

Il est accordé la permission de créer et de distribuer des copies littérales de cette page de manuel, à condition que l'avis de copyright et cet avis de permission soient conservés sur toutes les copies.

Il est accordé la permission de copier et de distribuer des versions modifiées de cette page de manuel sous les conditions de copie littérale, à condition que l'ensemble de l'œuvre dérivée résultante soit distribué sous les termes d'un avis de permission identique à celui-ci.

Il est accordé la permission de copier et de distribuer des traductions de cette page de manuel dans une autre langue, sous les conditions ci-dessus pour les versions modifiées, sauf que cet avis de permission peut être indiqué dans une traduction approuvée par la Fondation.