mawk - En ligne dans le Cloud

PROGRAMME:

Nom

mawk - langage de balayage de modèle et de traitement de texte

SYNOPSIS

gueule [-W option] [-F Plus-value] [-v var=valeur] [--] 'texte du programme' [fichier ...]
gueule [-W option] [-F Plus-value] [-v var=valeur] [-f fichier-programme] [--] [déposer ...]

DESCRIPTION

gueule est un interpréteur pour le langage de programmation AWK. Le langage AWK est utile pour
la manipulation de fichiers de données, la récupération et le traitement de texte, et pour le prototypage et
expérimenter des algorithmes. gueule est une neufs awk ce qui signifie qu'il implémente le langage AWK
tel que défini dans Aho, Kernighan et Weinberger, La AWK Programmation La langue, Addison Wesley
Publishing, 1988. (Ci-après dénommé le livre AWK.) gueule conforme à la Posix
1003.2 (ébauche 11.3) définition du langage AWK qui contient quelques fonctionnalités non
décrit dans le livre AWK, et gueule fournit un petit nombre d'extensions.

Un programme AWK est une séquence de modèle {action} paires et définitions de fonctions. Court
les programmes sont entrés sur la ligne de commande généralement entourés de ' ' pour éviter le shell
interprétation. Des programmes plus longs peuvent être lus à partir d'un fichier avec l'option -f. Données
l'entrée est lue à partir de la liste des fichiers sur la ligne de commande ou à partir de l'entrée standard lorsque le
la liste est vide. L'entrée est divisée en enregistrements comme déterminé par le séparateur d'enregistrements
variable, RS. Initialement, RS = "\n" et les enregistrements sont synonymes de lignes. Chaque enregistrement est
comparé à chacun modèle et s'il correspond, le texte du programme pour {action} is
réalisé.

OPTIONS

-F Plus-value définit le séparateur de champs, FS, to Plus-value.

-f filet Le texte du programme est lu à partir de filet au lieu de la ligne de commande. Plusieurs
-f les options sont autorisées.

-v var=valeur assigne Plus-value pour programmer la variable var.

-- indique la fin non ambiguë des options.

Les options ci-dessus seront disponibles avec toute implémentation compatible Posix d'AWK, et
les options spécifiques à la mise en œuvre sont précédées de -W. gueule en propose six :

-W version gueule écrit sa version et ses droits d'auteur sur stdout et les limites compilées sur
stderr et quitte 0.

-W dump écrit un assembleur comme la liste de la représentation interne du
programme sur stdout et quitte 0 (en cas de compilation réussie).

-W Interactive définit les écritures non tamponnées sur stdout et les lectures tamponnées par ligne à partir de stdin.
Les enregistrements de stdin sont des lignes quelle que soit la valeur de RS.

-W exec filet Le texte du programme est lu à partir de filet et c'est la dernière option. Utile sur
systèmes qui prennent en charge la #! convention "nombre magique" pour l'exécutable
scripts.

-W sprintf=num ajuste la taille de mawk's tampon sprintf interne à num octets. Plus que
l'utilisation rare de cette option indique gueule doit être recompilé.

-W posix_space force gueule ne pas considérer '\n' comme un espace.

Les formes courtes -W[vdiesp] sont reconnus et sur certains systèmes -We est obligatoire pour éviter
limites de longueur de ligne de commande.

LES AWK LANGUAGE

1. Programme structure
Un programme AWK est une séquence de modèle {action} paires et définitions de fonctions utilisateur.

Un motif peut être :
COMMENCER
FIN
expression
expression, expression

Un, mais pas les deux, de modèle {action} peut être omis. Si {action} est omis c'est
implicitement { imprimer }. Si modèle est omis, alors il est implicitement mis en correspondance. COMMENCER et
FIN les modèles nécessitent une action.

Les instructions se terminent par des sauts de ligne, des points-virgules ou les deux. Des groupes d'énoncés tels que
les actions ou les corps de boucle sont bloqués via { ... } comme en C. La dernière instruction d'un bloc
n'a pas besoin de terminateur. Les lignes vides n'ont aucun sens ; une instruction vide est terminée
avec un point-virgule. Les instructions longues peuvent être continuées avec une barre oblique inverse, \. Une déclaration peut
être rompu sans barre oblique inverse après une virgule, une accolade gauche, &&, ||, do, d'autre, la droite
parenthèse d'un if, tout en or en instruction, et la parenthèse droite d'une fonction
définition. Un commentaire commence par # et s'étend jusqu'à, mais n'inclut pas la fin de la ligne.

Les instructions suivantes contrôlent le déroulement du programme à l'intérieur des blocs.

if ( expr ) déclaration

if ( expr ) déclaration d'autre déclaration

tout en ( expr ) déclaration

do déclaration tout en ( expr )

en ( opt_expr ; opt_expr ; opt_expr ) déclaration

en ( var in tableau ) déclaration

continuer

pause

2. Données les types, Conversion et Comparaison
Il existe deux types de données de base, numérique et chaîne. Les constantes numériques peuvent être des entiers comme
-2, décimal comme 1.08, ou en notation scientifique comme -1.1e4 ou .28E-3. Tous les nombres sont
représenté en interne et tous les calculs sont effectués en arithmétique à virgule flottante. Donc pour
exemple, l'expression 0.2e2 == 20 est vraie et vraie est représentée par 1.0.

Les constantes de chaîne sont entourées de guillemets doubles.

"Ceci est une chaîne avec une nouvelle ligne à la fin.\n"

Les chaînes peuvent se poursuivre sur une ligne en échappant (\) à la nouvelle ligne. L'évasion suivante
les séquences sont reconnues.

\\ \
\" "
\a alerte, ascii 7
\b retour arrière, ascii 8
\t onglet, ascii 9
\n saut de ligne, ascii 10
\v onglet vertical, ascii 11
\f saut de page, ascii 12
\r retour chariot, ascii 13
\ddd 1, 2 ou 3 chiffres octaux pour ascii ddd
\xhh 1 ou 2 chiffres hexadécimaux pour ascii hh

Si vous échappez à tout autre caractère \c, vous obtenez \c, c'est-à-dire, gueule ignore l'évasion.

Il existe en réalité trois types de données de base ; le troisième est nombre et un magnifique qui a à la fois un
valeur numérique et une valeur de chaîne en même temps. Les variables définies par l'utilisateur entrent dans
existence lorsqu'ils sont référencés pour la première fois et sont initialisés à nul, un nombre et une valeur de chaîne
qui a la valeur numérique 0 et la valeur de chaîne "". Nombre non trivial et données de type chaîne
proviennent d'entrées et sont généralement stockés dans des champs. (Voir rubrique 4).

Le type d'une expression est déterminé par son contexte et la conversion automatique de type
se produit si nécessaire. Par exemple, pour évaluer les déclarations

y = x + 2 ; z = x "bonjour"

La valeur stockée dans la variable y sera de type numérique. Si x n'est pas numérique, la valeur lue
de x est converti en numérique avant d'être ajouté à 2 et stocké dans y. La valeur stockée
dans la variable z sera tapé chaîne, et la valeur de x sera convertie en chaîne si
nécessaire et concaténé avec "bonjour". (Bien sûr, la valeur et le type stockés dans x sont
pas modifié par aucune conversion.) Une expression de chaîne est convertie en numérique à l'aide de son
plus long préfixe numérique comme avec àtof(3). Une expression numérique est convertie en chaîne par
remplaçant expr avec sprintf(CONVFMT, expr), sauf si expr peut être représenté sur l'hôte
machine sous forme d'entier exact, puis il est converti en sprintf("%ré", expr). Sprintf() est un
AWK intégré qui duplique la fonctionnalité de sprintf(3), et CONVFMT est un intégré
variable utilisée pour la conversion interne de nombre en chaîne et initialisée à "%.6g".
Les conversions de types explicites peuvent être forcées, expr "" est une chaîne et expr+0 est numérique.

Évaluer, expr1 reprise expr2, si les deux opérandes sont numériques ou nombre et chaîne alors
la comparaison est numérique ; si les deux opérandes sont une chaîne, la comparaison est une chaîne ; Si un
l'opérande est une chaîne, l'opérande non-chaîne est converti et la comparaison est une chaîne. Les
le résultat est numérique, 1 ou 0.

Dans des contextes booléens tels que, if ( expr ) déclaration, une expression de chaîne évalue vrai si
et seulement s'il ne s'agit pas de la chaîne vide "" ; valeurs numériques si et seulement sinon numériquement
zéro.

3. Un coupage régulier expressions
Dans le langage AWK, les enregistrements, les champs et les chaînes sont souvent testés pour faire correspondre un Standard
expression. Les expressions régulières sont entourées de barres obliques et

expr ~ /r/

est une expression AWK qui vaut 1 si expr "allumettes" r, ce qui signifie une sous-chaîne de
expr est dans l'ensemble de chaînes défini par r. Sans correspondance, l'expression est évaluée à 0 ;
remplacer ~ par l'opérateur "pas de correspondance", !~ , inverse le sens. Comme modèle-action
paires,

/r/ { action } et $0 ~ /r/ { action }

sont les mêmes, et pour chaque enregistrement d'entrée qui correspond r, action est exécuté. En réalité, /r/
est une expression AWK équivalente à ($0 ~ /r/) n'importe où sauf à droite
côté d'un opérateur de correspondance ou passé en argument à une fonction intégrée qui attend un
argument d'expression régulière.

AWK utilise des expressions régulières étendues comme avec égrep(1). L'expression régulière
les métacaractères, c'est-à-dire ceux qui ont une signification particulière dans les expressions régulières sont

^$. [ ] | ( ) * + ?

Les expressions régulières sont construites à partir de caractères comme suit :

c correspond à n'importe quel non-métacaractère c.

\c correspond à un caractère défini par les mêmes séquences d'échappement utilisées dans
constantes de chaîne ou le caractère littéral c si \c n'est pas une évasion
séquence.

. correspond à n'importe quel caractère (y compris la nouvelle ligne).

^ correspond au début d'une chaîne.

$ correspond à l'arrière d'une chaîne.

[c1c2c3...] correspond à n'importe quel caractère de la classe c1c2c3... . Un intervalle de
caractères est noté c1-c2 à l'intérieur d'une classe [...].

[^c1c2c3...] correspond à tout caractère n'appartenant pas à la classe c1c2c3...

Les expressions régulières sont construites à partir d'autres expressions régulières comme suit :

r1r2 matches r1 suivi immédiatement de r2 (enchaînement).

r1 | r2 matches r1 ou r2 (alternance).

r* allumettes r répété zéro ou plusieurs fois.

r+ allumettes r répété une ou plusieurs fois.

r? allumettes r zéro ou une fois.

(r) allumettes r, assurant le regroupement.

La priorité croissante des opérateurs est l'alternance, la concaténation et l'unaire (*, + ou
?).

Par exemple,

/^[_a-zA-Z][_a-zA-Z0-9]*$/ et
/^[-+]?([0-9]+\.?|\.[0-9])[0-9]*([eE][-+]?[0-9]+)?$/

correspondent respectivement aux identifiants AWK et aux constantes numériques AWK. Noter que . doit
être échappé pour être reconnu comme un point décimal, et que les métacaractères ne sont pas spéciaux
à l'intérieur des classes de caractères.

Toute expression peut être utilisée à droite des opérateurs ~ ou !~ ou transmise à un
intégré qui attend une expression régulière. Si nécessaire, il est converti en chaîne, et
alors interprété comme une expression régulière. Par exemple,

COMMENCER { identifiant = "[_a-zA-Z][_a-zA-Z0-9]*" }

$0 ~ "^" identifiant

imprime toutes les lignes commençant par un identifiant AWK.

gueule reconnaît l'expression régulière vide, //, qui correspond à la chaîne vide et donc
correspond à n'importe quelle chaîne au début, à l'arrière et entre chaque caractère. Par exemple,

écho abc | mawk { gsub(//, "X") ; imprimer }
XaXbXcX

4. Enregistrements et des champs
Les enregistrements sont lus un par un et stockés dans le champ variable $0. Le dossier est
séparé en des champs qui sont stockés dans $1, $2, ..., $NF. La variable intégrée NF est réglé
au nombre de champs, et NR et RNR sont incrémentés de 1. Les champs ci-dessus $NF sont mis à
"".

Affectation à $0 provoque les champs et NF à recalculer. Affectation à NF ou à un
causes sur le terrain $0 à reconstruire en concaténant les $i's séparé par BSF.
Affectation à un champ d'index supérieur à NF, augmente NF et causes $0 être
reconstruit.

L'entrée de données stockée dans les champs est une chaîne, sauf si le champ entier a une forme numérique, puis
le type est nombre et chaîne. Par exemple,

écho 24 24E |
mawk '{ print($1>100, $1>"100", $2>100, $2>"100") }'
0 1 1 1

$0 et $2 sont des cordes et $1 est un nombre et une chaîne. La première comparaison est numérique, la
le deuxième est une chaîne, le troisième est une chaîne (100 est converti en "100") et le dernier est une chaîne.

5. Expressions et opérateurs
La syntaxe de l'expression est similaire à C. Les expressions principales sont des constantes numériques, des chaînes
constantes, variables, champs, tableaux et appels de fonction. L'identifiant d'une variable,
un tableau ou une fonction peut être une séquence de lettres, de chiffres et de traits de soulignement, qui ne
commencer par un chiffre. Les variables ne sont pas déclarées ; ils existent lorsqu'ils sont référencés pour la première fois et sont
initialisé à nul.

Les nouvelles expressions sont composées avec les opérateurs suivants dans l'ordre croissant
priorité.

affectation = += -= *= /= %= ^=
conditionnels. ? :
logique or ||
logique et &&
tableau Adhésion in
assorti ~ !~
relationnel < > <= >= == !=
enchaînement (pas d'opérateur explicite)
ajouter ops + -
mul ops * /%
unaire + -
logique ne sauraient !
exponentiation ^
inc et déc ++ -- (à la fois post et pré)
champ $

L'affectation, le conditionnel et l'exponentiation s'associent de droite à gauche ; les autres opérateurs
associer de gauche à droite. Toute expression peut être mise entre parenthèses.

6. Arrays
Awk fournit des tableaux à une dimension. Les éléments du tableau sont exprimés sous la forme tableau[expr]. Expr
est converti en interne en type chaîne, donc, par exemple, A[1] et A["1"] sont les mêmes
élément et l'indice réel est "1". Les tableaux indexés par des chaînes sont appelés associatifs
tableaux. Initialement, un tableau est vide ; éléments existent lors du premier accès. Une expression,
expr in tableau vaut 1 si tableau[expr] existe, sinon à 0.

Il existe une forme de en instruction qui boucle sur chaque index d'un tableau.

en ( var in tableau ) déclaration

ensembles var à chaque indice de tableau et exécute déclaration. L'ordre qui var transversales
les indices de tableau n'est pas défini.

La déclaration, effacer tableau[expr], provoque tableau[expr] de ne pas exister. gueule prend en charge un
extension, effacer tableau, qui supprime tous les éléments de tableau.

Les tableaux multidimensionnels sont synthétisés avec concaténation à l'aide de la variable intégrée
SOUS-SEP. tableau[expr1,expr2] équivaut à tableau[expr1 SOUS-SEP expr2]. Test pour un
élément multidimensionnel utilise un index entre parenthèses, tel que

si ( (i, j) dans A ) imprime A[i, j]

7. Variables intégrées
Les variables suivantes sont intégrées et initialisées avant l'exécution du programme.

ARGC nombre d'arguments de ligne de commande.

ARGV tableau d'arguments de ligne de commande, 0..ARGC-1.

CONVFMT format de conversion interne des nombres en chaîne, initialement = "%.6g".

ENVIRONNEMENT tableau indexé par des variables d'environnement. Une chaîne d'environnement, var=valeur
est stocké comme ENVIRONNEMENT[var🇧🇷 Plus-value.

NOM DE FICHIER nom du fichier d'entrée courant.

RNR numéro d'enregistrement actuel dans NOM DE FICHIER.

FS divise les enregistrements en champs en tant qu'expression régulière.

NF nombre de champs dans l'enregistrement courant.

NR numéro d'enregistrement actuel dans le flux d'entrée total.

OFMT format d'impression des nombres ; initialement = "%.6g".

BSF inséré entre les champs en sortie, initialement = " ".

ORS termine chaque enregistrement en sortie, initialement = "\n".

LONGUEUR longueur définie par le dernier appel à la fonction intégrée, rencontre().

RS séparateur d'enregistrement d'entrée, initialement = "\n".

DÉMARRER index défini par le dernier appel à rencontre().

SOUS-SEP utilisé pour construire plusieurs indices de tableau, initialement = "\034".

8. Encastré fonctions
Fonctions de chaîne

gsub(r, s, t) gsub(r, s)
Substitution globale, chaque correspondance d'expression régulière r en variable t is
remplacé par chaîne s. Le nombre de remplacements est retourné. Si t is
omis, $0 est utilisé. Un & dans la chaîne de remplacement s est remplacé par le
sous-chaîne correspondante de t. \& et \\ mettent les littéraux & et \, respectivement, dans
la chaîne de remplacement.

indice(s, t)
If t est une sous-chaîne de s, puis la position où t commence est renvoyé, sinon
0 est renvoyé. Le premier personnage de s est en position 1.

longueur(s)
Renvoie la longueur de la chaîne s.

rencontre(s, r)
Renvoie l'index de la première correspondance la plus longue de l'expression régulière r in
un magnifique s. Renvoie 0 si aucune correspondance. Comme effet secondaire, DÉMARRER est réglé sur la
valeur de retour. LONGUEUR est défini sur la longueur de la correspondance ou -1 si aucune correspondance.
Si la chaîne vide correspond, LONGUEUR est mis à 0, et 1 est renvoyé si
l'allumette est à l'avant, et la longueur(s)+1 est renvoyé si la correspondance est à
l'arrière.

diviser(s, un, r) diviser(s, un)
Chaîne s est divisé en champs par une expression régulière r et les champs sont
chargé dans le tableau A. Le nombre de champs est renvoyé. Voir l'article 11
ci-dessous pour plus de détails. Si r est omis, FS est utilisé.

sprintf (format,liste-expr)
Renvoie une chaîne construite à partir de liste_expr selon le format. Voir l'
description de printf() ci-dessous.

sous(r, s, t) sous(r, s)
Substitution unique, identique à gsub() sauf au plus une substitution.

sous-str(péché) sousstr(si)
Renvoie la sous-chaîne de chaîne s, à partir de l'index i, de longueur n. Si n
est omis, le suffixe de s, À partir de i Est retourné.

baisser(s)
Renvoie une copie de s avec tous les caractères majuscules convertis en minuscules.

toupie(s)
Renvoie une copie de s avec tous les caractères minuscules convertis en majuscules.

Fonctions arithmétiques

atan2(y, x) Arctan de y/x entre -pi et pi.

cos (x) Fonction cosinus, x en radians.

exp (x) Fonction exponentielle.

int (x) Retour x tronqué vers zéro.

Journal(x) Un algorithme naturel.

rand() Renvoie un nombre aléatoire entre zéro et un.

péché(x) Fonction sinus, x en radians.

carré(x) Renvoie la racine carrée de x.

srand(expr) srand()
Amorce le générateur de nombres aléatoires, en utilisant l'horloge si expr est omis, et
renvoie la valeur de la graine précédente. gueule graines le nombre aléatoire
générateur de l'horloge au démarrage donc il n'y a pas vraiment besoin d'appeler
srand(). Srand(expr) est utile pour répéter des séquences pseudo-aléatoires.

9. Entrée et sortie
Il y a deux instructions de sortie, impression et printf.

impression écrit $0 ORS à la sortie standard.

impression expr1, expr2, ..., exprn
écrit expr1 BSF expr2 BSF exprn ORS à la sortie standard. Numérique
les expressions sont converties en chaîne avec OFMT.

printf le format, liste_expr
duplique la fonction de bibliothèque printf C en écrivant sur la sortie standard. Les
les spécifications complètes du format ANSI C sont reconnues avec les conversions %c,
%d, %e, %E, %f, %g, %G, %i, %o, %s, %u, %x, %X et %%, et conversion
qualificatifs h et l.

La liste d'arguments de print ou printf peut éventuellement être mise entre parenthèses. Imprimer
formate les nombres à l'aide OFMT ou "%d" pour les entiers exacts. "%c" avec un argument numérique
imprime le caractère 8 bits correspondant, avec un argument de chaîne, il imprime le premier
caractère de la chaîne. La sortie de print et printf peut être redirigée vers un fichier ou
commande en ajoutant > filet, >> filet ou | commander à la fin de l'instruction d'impression.
La redirection s'ouvre filet or commander une seule fois, les redirections suivantes s'ajoutent au déjà
flux ouvert. Par convention, gueule associe le nom de fichier "/dev/stder" avec stderr qui
permet à print et printf d'être redirigés vers stderr. gueule associe également "-" et
"/dev/stdout" avec stdin et stdout qui permet de transmettre ces flux aux fonctions.

La fonction d'entrée obtenir la ligne a les variantes suivantes.

obtenir la ligne
lit dans $0, met à jour les champs, NF, NR et RNR.

obtenir la ligne filet
lit dans $0 de filet, met à jour les champs et NF.

obtenir la ligne var
lit l'enregistrement suivant dans var, mises à jour NR et RNR.

obtenir la ligne var < filet
lit le prochain enregistrement de filet développement var.

commander | obtenir la ligne
envoie un enregistrement de commander développement $0 et met à jour les champs et NF.

commander | obtenir la ligne var
envoie un enregistrement de commander développement var.

Getline renvoie 0 à la fin du fichier, -1 en cas d'erreur, sinon 1.

Les commandes à la fin des tuyaux sont exécutées par /bin/sh.

La fonction close(expr) ferme le fichier ou le tube associé à expr. Fermer renvoie 0 si
expr est un fichier ouvert, l'état de sortie si expr est une commande canalisée, et -1 sinon. proche
est utilisé pour relire un fichier ou une commande, assurez-vous que l'autre extrémité d'un tube de sortie est terminée
ou conserver les ressources des fichiers.

La fonction chasser(expr) vide le fichier ou le tube de sortie associé à expr. Rincer
renvoie 0 si expr est un flux de sortie ouvert else -1. Fflush sans argument
sortie standard. Fflush avec un argument vide ("") vide toutes les sorties ouvertes.

La fonction combustion propre(expr) les usages / Bin / sh éxécuter expr et renvoie l'état de sortie du
commander expr. Les modifications apportées au ENVIRONNEMENT array ne sont pas passés aux commandes exécutées avec
combustion propre ou des tuyaux.

10. Utilisateur défini fonctions
La syntaxe d'une fonction définie par l'utilisateur est

fonction nom ( args ) { déclarations }

Le corps de la fonction peut contenir une instruction return

retourner opt_expr

Une déclaration de retour n'est pas requise. Les appels de fonction peuvent être imbriqués ou récursifs. Les fonctions
sont passés des expressions par valeur et des tableaux par référence. Les arguments supplémentaires servent de local
variables et sont initialisés à nul. Par exemple, csplit(s, un) met chaque caractère de s
en tableau A et renvoie la longueur de s.

fonction csplit(s, A, n, i)
{
n = longueur(s)
for( i = 1 ; i <= n ; i++ ) A[i] = substr(s, i, 1)
retour m
}

Mettre un espace supplémentaire entre les arguments passés et les variables locales est conventionnel.
Les fonctions peuvent être référencées avant d'être définies, mais le nom de la fonction et le '(' de
les arguments doivent se toucher pour éviter toute confusion avec la concaténation.

11. Scission cordes, Articles et fichiers
Les programmes Awk utilisent le même algorithme pour diviser les chaînes en tableaux avec split() et les enregistrements
dans les champs sur FS. gueule utilise essentiellement le même algorithme pour diviser les fichiers en enregistrements
on RS.

Diviser(expr, A, sep) fonctionne comme suit :

(1) Si sep est omis, il est remplacé par FS. Sep peut être une expression ou
expression régulière. S'il s'agit d'une expression de type non chaîne, c'est
converti en chaîne.

(2) Si sep = " " (un seul espace), alors est coupé par l'avant et
arrière expret sep devient . gueule définit comme le régulier
expression /[ \t\n]+/. Autrement sep est traité comme une expression régulière,
sauf que les méta-caractères sont ignorés pour une chaîne de longueur 1, par exemple,
split(x, A, "*") et split(x, A, /\*/) sont identiques.

(3) Si expr n'est pas une chaîne, il est converti en chaîne. Si expr est alors le vide
chaîne "", split() renvoie 0 et A est défini vide. Sinon, tous les non-
correspondances qui se chevauchent, non nulles et les plus longues de sep in expr, séparé expr développement
champs qui sont chargés dans A. Les champs sont placés en A[1], A[2], ...,
A[n] et split() renvoient n, le nombre de champs qui est le nombre de
allumettes plus un. Les données placées dans A qui semble numérique est tapé nombre et
chaîne.

La division des enregistrements en champs fonctionne de la même manière, sauf que les éléments sont chargés dans $1, $2, ...,
$NF. Si $0 est vide, NF est mis à 0 et tout $i à "".

gueule divise les fichiers en enregistrements par le même algorithme, mais avec la légère différence que
RS est vraiment un terminateur au lieu d'un séparateur. (ORS est vraiment un terminateur aussi).

Par exemple, si FS = ":+" et $0 = "a::b:" , alors NF = 3 et $1 = "un", $2 = "b" et $3 =
"", mais si "a::b:" est le contenu d'un fichier d'entrée et RS = ":+", alors il y a
deux enregistrements "a" et "b".

RS = " " n'est pas spécial.

If FS = "", alors gueule bat le record en caractères individuels et, de la même manière,
diviser(s, un,"") place les caractères individuels de s développement A.

12. Multi-ligne Articles
Depuis que gueule interprète RS en tant qu'expression régulière, les enregistrements multilignes sont faciles. Réglage RS
= "\n\n+", crée une ou plusieurs lignes vides pour séparer les enregistrements. Si FS = " " (la valeur par défaut),
puis des sauts de ligne simples, selon les règles de ci-dessus, deviennent de l'espace et des nouvelles lignes simples sont
séparateurs de champs.

Par exemple, si un fichier est "ab\nc\n\n", RS = "\n\n+" et FS = " ", alors il y a
un enregistrement "ab\nc" avec trois champs "a", "b" et "c". En changeant FS = "\n", donne
deux champs "ab" et "c" ; en changeant FS = "", donne un champ identique au
record.

Si vous souhaitez que les lignes avec des espaces ou des tabulations soient considérées comme vides, définissez RS = "\n([ \t]*\n)+".
Pour la compatibilité avec d'autres awks, le réglage RS = "" a le même effet que si des lignes vides
sont supprimés du recto et du verso des fichiers, puis les enregistrements sont déterminés comme si RS =
"\n\n+". Posix exige que "\n" sépare toujours les enregistrements lorsque RS = "" quel que soit le
valeur de FS. gueule ne prend pas en charge cette convention, car définir "\n" comme
le rend inutile.

La plupart du temps, lorsque vous changez RS pour les enregistrements multilignes, vous souhaiterez également modifier
ORS à "\n\n" afin que l'espacement des enregistrements soit conservé à la sortie.

13. Programme exécution
Cette section décrit l'ordre d'exécution du programme. D'abord ARGC est fixé au total
nombre d'arguments de ligne de commande passés à la phase d'exécution du programme. ARGV[0] is
définir le nom de l'interpréteur AWK et ARGV[1] ARGV[ARGC-1] détient le reste
arguments de ligne de commande exclusifs des options et de la source du programme. Par exemple avec

mawk -f prog v=1 A t=bonjour B

ARGC = 5 avec ARGV[0] = "mawk", ARGV[1] = "v=1", ARGV[2] = "A", ARGV[3] = "t=bonjour" et
ARGV[4] = "B".

Ensuite, chaque COMMENCER bloc est exécuté dans l'ordre. Si le programme se compose entièrement de COMMENCER
blocs, puis l'exécution se termine, sinon un flux d'entrée est ouvert et l'exécution se poursuit.
If ARGC est égal à 1, le flux d'entrée est défini sur stdin, sinon les arguments de la ligne de commande
ARGV[1] ARGV[ARGC-1] sont examinés pour un argument de fichier.

Les arguments de la ligne de commande se divisent en trois ensembles : arguments de fichier, arguments d'affectation
et des chaînes vides "". Un devoir a la forme var=un magnifique. Quand un ARGV[je] est examiné
comme argument de fichier possible, s'il est vide, il est ignoré ; si c'est un devoir
argument, l'affectation à var a lieu et i passe à l'argument suivant ; autre ARGV[je]
est ouvert pour la saisie. S'il ne s'ouvre pas, l'exécution se termine avec le code de sortie 2. Si non
l'argument de ligne de commande est un argument de fichier, alors l'entrée provient de stdin. Getline dans un COMMENCER
l'action ouvre l'entrée. "-" comme argument de fichier indique stdin.

Une fois qu'un flux d'entrée est ouvert, chaque enregistrement d'entrée est testé par rapport à chaque modèle, et s'il
matchs, les associés action est exécuté. Un modèle d'expression correspond s'il est
boolean true (voir la fin de la section 2). UNE COMMENCER correspondances de motif avant qu'une entrée n'ait
été lu, et un FIN le motif correspond une fois que toutes les entrées ont été lues. Un modèle de gamme,
expr1,expr2, correspond à chaque enregistrement entre le match de expr1 et le match expr2
inclusivement.

Lorsque la fin du fichier se produit sur le flux d'entrée, les arguments de ligne de commande restants sont
examiné pour un argument de fichier, et s'il y en a un, il est ouvert, sinon le FIN modèle is
considérés comme appariés et tous FIN actes sont exécutés.

Dans l'exemple, l'affectation v=1 a lieu après la COMMENCER actes sont exécutés, et
les données placées dans v sont tapées nombre et chaîne. L'entrée est ensuite lue à partir du fichier A. À la fin
du fichier A, t est défini sur la chaîne "hello", et B est ouvert pour la saisie. A la fin du fichier B,
le FIN actes sont exécutés.

Déroulement du programme au modèle {action} le niveau peut être modifié avec le

next
sortie opt_expr

déclarations. UNE next L'instruction provoque la lecture de l'enregistrement d'entrée suivant et le test de modèle
recommencer avec le premier modèle {action} paire dans le programme. Un sortie cause de l'énoncé
exécution immédiate de la FIN actions ou la fin du programme s'il n'y en a pas ou si le
sortie se produit dans un FIN action. Les opt_expr définit la valeur de sortie du programme à moins que
remplacé par un plus tard sortie ou erreur ultérieure.

EXEMPLES

1. imiter le chat.

{ imprimer }

2. imiter les toilettes.

{ chars += longueur($0) + 1 # ajouter un pour le \n
mots += NF
}

END{ imprimer NR, mots, caractères }

3. compter le nombre de « vrais mots » uniques.

COMMENCER { FS = "[^A-Za-z]+" }

{ for(i = 1 ; i <= NF ; i++) mot[$i] = "" }

END { supprimer le mot[""]
pour ( je dans le mot ) cnt++
imprimer cnt
}

4. additionner le deuxième champ de chaque enregistrement basé sur le premier champ.

$1 ~ /crédit|gain/ { somme += $2 }
$1 ~ /débit|perte/ { somme -= $2 }

END { imprimer la somme }

5. trier un fichier, en le comparant sous forme de chaîne

{ line[NR] = $0 "" } # assurez-vous du type de comparaison
# au cas où certaines lignes semblent numériques

END { isort(ligne, NR)
for(i = 1 ; i <= NR ; i++) imprimer la ligne[i]
}

#insertion sorte de A[1..n]
fonction isort( A, n, i, j, hold)
{
pour( i = 2 ; i <= n ; i++)
{
tenir = A[j = i]
while ( A[j-1] > hold )
{j-- ; UNE[j+1] = UNE[j] }
A[j] = tenir
}
# sentinelle A[0] = "" sera créé si besoin
}

COMPATIBILITÉ QUESTIONS

La définition Posix 1003.2 (draft 11.3) du langage AWK est AWK comme décrit dans l'AWK
livre avec quelques extensions apparues dans SystemVR4 nawk. Les extensions sont :

Nouvelles fonctions : toupper() et tolower().

Nouvelles variables : ENVIRON[] et CONVFMT.

Spécifications de conversion ANSI C pour printf() et sprintf().

Nouvelles options de commande : -v var=valeur, plusieurs options -f et options d'implémentation
comme arguments de -W.

Posix AWK est conçu pour opérer sur des fichiers ligne par ligne. RS peut être modifié à partir de "\n"
à un autre personnage, mais il est difficile de lui trouver une utilité — il n'y a pas
exemples dans le livre AWK. Par convention, RS = "", sépare une ou plusieurs lignes vierges
enregistrements, permettant des enregistrements multilignes. Lorsque RS = "", "\n" est toujours un séparateur de champs
quelle que soit la valeur de FS.

gueule, d'autre part, permet RS être une expression régulière. Lorsque "\n" apparaît dans
enregistrements, il est traité comme un espace, et FS détermine toujours les champs.

La suppression du paradigme ligne par ligne peut simplifier certains programmes et peut souvent s'améliorer
performance. Par exemple, en reprenant l'exemple 3 ci-dessus,

COMMENCER { RS = "[^A-Za-z]+" }

{ mot[ $0 ] = "" }

END { supprimer le mot[ "" ]
pour( je dans mot ) cnt++
imprimer cnt
}

compte le nombre de mots uniques en faisant de chaque mot un enregistrement. Sur des fichiers de taille moyenne,
gueule s'exécute deux fois plus vite, en raison de la boucle interne simplifiée.

Le programme suivant remplace chaque commentaire par un seul espace dans un fichier programme C,

COMMENCER {
RS = "/\*([^*]|\*+[^/*])*\*+/"
# commentaire est un séparateur d'enregistrements
SOR = " "
obtenir la ligne d'attente
}

{ attente d'impression ; attente = 0 $ }

END { printf "%s" , maintenez }

La mise en mémoire tampon d'un enregistrement est nécessaire pour éviter de terminer le dernier enregistrement par un espace.

Avec gueule, les éléments suivants sont tous équivalents,

x ~ /a\+b/ x ~ "a\+b" x ~ "a\\+b"

Les chaînes sont analysées deux fois, une fois en tant que chaîne et une fois en tant qu'expression régulière. Sur le
analyse de chaîne, gueule ignore l'échappement sur les caractères sans échappement tandis que le livre AWK préconise
\c être reconnu comme c qui nécessite la double échappée des méta-caractères dans
cordes. Posix refuse explicitement de définir le comportement qui force passivement les programmes
qui doit fonctionner sous une variété de awks pour utiliser le double, plus portable mais moins lisible
échapper.

Posix AWK ne reconnaît pas les séquences d'échappement "/dev/std{out,err}" ou \x hexadécimal dans les chaînes.
Contrairement à l'ANSI C, gueule limite le nombre de chiffres qui suivent \x à deux en tant que valeur actuelle
l'implémentation ne prend en charge que les caractères 8 bits. Le intégré chasser est apparu pour la première fois dans un
récent (1993) AT&T awk publié sur netlib et ne fait pas partie du standard posix.
Suppression agrégée avec effacer tableau ne fait pas partie de la norme posix.

Posix laisse explicitement le comportement de FS = "" non défini, et mentionne le fractionnement du
enregistrer en caractères comme interprétation possible, mais actuellement cette utilisation n'est pas
portable à travers les implémentations.

Enfin, voici comment gueule traite des cas exceptionnels non abordés dans le livre AWK ou le
Brouillon Posix. Il n'est pas prudent de supposer la cohérence entre les awks et de passer au suivant en toute sécurité
.

substr(s, i, n) renvoie les caractères de s à l'intersection des fermés
l'intervalle [1, longueur(s)] et l'intervalle semi-ouvert [i, i+n). Quand ce
l'intersection est vide, la chaîne vide est renvoyée ; donc substr("ABC", 1, 0) = ""
et substr("ABC", -4, 6) = "A".

Chaque chaîne, y compris la chaîne vide, correspond à la chaîne vide au début donc,
s ~ // et s ~ "", valent toujours 1 tout comme match(s, //) et match(s, ""). Les deux derniers
set LONGUEUR à 0.

index(s, t) est toujours le même que match(s, t1) où t1 est le même que t avec
les métacaractères se sont échappés. Par conséquent, la cohérence avec la correspondance nécessite que l'index (s, "")
renvoie toujours 1. Aussi la condition, index(s,t) != 0 si et seulement t est une sous-chaîne
de s, nécessite index("","") = 1.

Si getline rencontre la fin du fichier, getline var, laisse var inchangé. De la même manière,
à l'entrée de la FIN Actions, $0, les champs et NF ont leur valeur inchangée de
le dernier enregistrement.

Utiliser mawk en ligne à l'aide des services onworks.net