Provided by: manpages-it_4.19.0-7_all 
NOME
gawk - linguaggio per il riconoscimento e il trattamento di espressioni regolari
SINTASSI
gawk [ opzioni in stile POSIX o GNU ] -f file di programma [ -- ] file ...
gawk [ opzioni in stile POSIX o GNU ] [ -- ] testo del programma file ...
DESCRIZIONE
Gawk è l'implementazione nell'ambito del Progetto GNU del linguaggio di programmazione
AWK. Si attiene alla definizione del linguaggio descritta nello standard POSIX 1003.1.
Questa versione è basata a sua volta sulla descrizione contenuta in The AWK Programming
Language, di Aho, Kernighan e Weinberger. Gawk fornisce le funzionalità aggiuntive
presenti nella versione corrente di awk di Brian Kernighan e numerose estensioni
specifiche di GNU.
La riga di comando contiene opzioni per gawk stesso, il testo del programma AWK (se non è
stato fornito con le opzioni -f or --include), e valori da rendere disponibili nelle
variabili AWK predefinite ARGC e ARGV.
PREFACE
This manual page is intentionally as terse as possible. Full details are provided in
GAWK: Effective AWK Programming, and you should look there for the full story on any
specific feature. Where possible, links to the online version of the manual are provided.
FORMATO DELLE OPZIONI
Le opzioni di Gawk possono essere sia nella tradizionale forma a una lettera di POSIX, sia
nella forma estesa tipica di GNU. Le opzioni POSIX cominciano con un “-” singolo, quelle
in forma lunga cominciano con “--”. Sono disponibili opzioni in forma lunga sia per le
funzionalità specifiche di GNU, sia per quelle previste da POSIX.
Le opzioni specifiche di gawk sono usate normalmente nella forma lunga. Gli argomenti
delle opzioni in forma lunga possono essere uniti ad esse da un segno =, senza spazi,
oppure sono indicati nel successivo argomento della riga di comando. Le opzioni lunghe
possono essere abbreviate, sempre che l'abbreviazione rimanga univoca.
In aggiunta, ogni opzione lunga ha una corrispondente opzione corta, in modo che la
funzionalità dell'opzione possa essere usata all'interno di script #! eseguibili.
OPZIONI
Gawk accetta le seguenti opzioni. Le opzioni standard sono elencate per prime, seguite
dalle opzioni per le estensioni gawk, elencate nell'ordine alfabetico delle opzioni corte.
-f file_di_programma-file,
--file program-file Read the AWK program source from the file program-file, instead
of from the first command line argument. Multiple -f options may be used. Files
read with -f are treated as if they begin with an implicit @namespace "awk"
statement.
-F fs, --field-separator fs Usa fs come separatore di campo in input (il valore della
variabile predefinita FS).
-v var=val, --assign var=val
Assegna il valore val alla variabile var, prima che inizi l'esecuzione del
programma. Questi valori delle variabili sono messi a disposizione della regola
BEGIN di un programma AWK.
-b, --characters-as-bytes Treat all input data as single-byte characters. The --posix
option overrides this one.
-c, --traditional Viene eseguito in modalità compatibile. In questa modalità, gawk si
comporta esattamente come awk di Brian Kernighan; non viene riconosciuta nessuna
delle estensioni specifiche di GNU.
-C, --copyright Stampa sullo standard output la versione sintetica del messaggio di
informazione sul copyright GNU ed esce senza segnalare errori.
-d[file], --dump-variables[=file]
Print a sorted list of global variables, their types and final values to file. The
default file is awkvars.out in the current directory.
-D[file], --debug[=file]
Abilita il debugging di programmi AWK. Per default, l'analizzatore di errori
[debugger] legge i comandi in maniera interattiva dalla tastiera (standard input).
L'argomento opzionale file specifica un file contenente un elenco di comandi per il
debugger da eseguire in maniera non interattiva.
In this mode of execution, gawk loads the AWK source code and then prompts for
debugging commands. Gawk can only debug AWK program source provided with the -f
and --include options. The debugger is documented in GAWK: Effective AWK
Programming; see
https://www.gnu.org/software/gawk/manual/html_node/Debugger.html#Debugger.
-e testo_del_programma,
--source program-text Use program-text as AWK program source code. Each argument
supplied via -e is treated as if it begins with an implicit @namespace "awk"
statement.
-E file, --exec file
Simile a -f, comunque, quest'opzione è l'ultima ad essere elaborata. Dovrebbe
essere usata con script #!, specialmente per applicazioni CGI [Common Gateway
Interface], per evitare di passare opzioni o codice (!) sulla riga di comando da un
URL. Quest'opzione disabilita gli assegnamenti di variabile da riga di comando.
-g, --gen-pot Esamina e analizza il programma AWK, e genera un file in formato GNU .pot
(Portable Object Template) sullo standard output con elementi relativi a tutte le
stringhe localizzabili nel programma. Il programma in sé non viene eseguito.
-h, Scrive sullo standard output un riassunto abbastanza breve delle opzioni
disponibili. In linea con le convenzioni di codifica GNU Coding Standards, queste
opzioni provocano un'uscita immediata e senza segnalazione di errore.
-i include-file, --include include-file
Carica una libreria di sorgenti awk. Cerca la libreria usando la variabile
d'ambiente AWKPATH. Se la ricerca iniziale non va a buon fine, viene fatto un altro
tentativo dopo aver aggiunto il suffisso .awk. Il file verrà caricato solo una
volta (cioè vengono ignorati i duplicati), e il codice non costituisce il sorgente
del programma principale. I file letti come specificato da --include sono trattati
come se iniziassero con la direttiva implicita @namespace "awk".
-I, --trace Stampa i nomi del codice-byte generato internamente, nell'ordine in cui
sono incontrati durante l'esecuzione del programma. Questa trace è stampata sullo
standard error. Ogni “codice operativo” è preceduto da un segno + nell'output.
-l lib,
--load lib Carica un'estensione gawk dalla libreria condivisa lib. Cerca la
libreria usando la variabile d'ambiente AWKLIBPATH. Se la ricerca iniziale non va a
buon fine, viene fatto un altro tentativo dopo aver aggiunto il suffisso della
libreria condivisa predefinita per la piattaforma. La procedura di inizializzazione
della libreria si suppone avere come nome dl_load().
-L [valore], --lint[=valore]
Provide warnings about constructs that are dubious or non-portable to other AWK
implementations. See
https://www.gnu.org/software/gawk/manual/html_node/Options.html#Options for the
list of possible values for value.
-M, --bignum Forza il calcolo con precisione arbitraria sui numeri. Quest'opzione non
ha effetto se gawk non è compilato per utilizzare le librerie GNU MPFR e GMP. (In
tal caso, gawk invia un messaggio di avvertimento.)
NOTE: This feature is on parole. The primary gawk maintainer is no longer
supporting it, although there is a member of the development team who is. If this
situation changes, the feature will be removed from gawk.
-n, --non-decimal-data Riconosce valori ottali ed esadecimali nei dati in input. Usare
quest'opzione con molta cautela!
-N, --use-lc-numeric Force gawk to use the locale's decimal point character when
parsing input data.
-o[file], --pretty-print[=file]
Output a pretty printed version of the program to file. The default file is
awkprof.out in the current directory. This option implies --no-optimize.
-O, --optimize Enable gawk's default optimizations upon the internal representation of
the program. This option is on by default.
-p[prof-file], --profile[=prof-file]
Start a profiling session, and send the profiling data to prof-file. The default
is awkprof.out in the current directory. The profile contains execution counts of
each statement in the program in the left margin and function call counts for each
user-defined function. Gawk runs more slowly in this mode. This option implies
--no-optimize.
-P, --posix This turns on compatibility mode, and disables a number of common
extensions.
-r, --re-interval Enable the use of interval expressions in regular expression
matching. Interval expressions are enabled by default, but this option remains for
backwards compatibility.
-s, --no-optimize Disabilita le ottimizzazioni predefinite di gawk nella
rappresentazione interna del programma.
-S, --sandbox Esegue gawk in modalità "sandbox", disabilitando la funzione system(), la
ridirezione dell'input con getline, la ridirezione sull'output con print e printf,
e il caricamento delle estensioni dinamiche. L'esecuzione di comandi (tramite
pipeline) è anch'essa disabilitata.
-t, --lint-old Emette messaggi d'avvertimento relativi a costrutti non portabili sulla
versione originale di awk per UNIX.
-V, --version Print version information for this particular copy of gawk on the
standard output. This is useful when reporting bugs. Per the GNU Coding
Standards, these options cause an immediate, successful exit.
-- Segnala la fine delle opzioni. È utile perché permette di passare al programma AWK
ulteriori argomenti [nomi di file] che iniziano con “-”.
In modalità compatibile, qualsiasi altra opzione è contrassegnata come non valida e viene
ignorata. Nell'uso normale, sempre che sia stato fornito il testo del programma, le
opzioni sconosciute sono passate al programma AWK nel vettore ARGV per l'elaborazione.
Per compatibilità con POSIX, si può usare l'opzione -W, seguita dal nome di un'opzione
lunga.
ESECUZIONE DEL PROGRAMMA AWK
Un programma AWK consiste di una sequenza di direttive opzionali, istruzioni di tipo
criterio-azione e definizioni di funzione opzionali.
@include "nome_del_file"
@load "nome_del_file"
@namespace "nome"
criterio di ricerca { istruzioni di azione }
function nome(lista di parametri) { istruzioni }
Gawk prima legge il codice del programma dal/dai file_di_programma se specificato/i, dagli
argomenti passati a --source, o dal primo argomento sulla riga di comando che non sia
un'opzione. Le opzioni -f e --source possono essere usate più volte nella riga di comando.
Gawk legge il testo del programma come se tutti i file_di_programma e i testi sorgenti
della riga di comando fossero concatenati.
Oltre a ciò, le righe che iniziano con @include possono essere usate per includere altri
file sorgenti nel programma. Questo è equivalente all'uso dell'opzione --include.
Le righe che iniziano con @load possono essere usate per caricare funzioni di estensione
nel programma. Questo è equivalente all'uso dell'opzione --load.
La variabile d'ambiente AWKPATH specifica il percorso lungo il quale cercare i file
sorgenti indicati con le opzioni -f e --include. Se questa variabile non esiste, il
percorso predefinito è ".:/usr/local/share/awk" (la directory in questione può variare a
seconda di come gawk è stato compilato e installato). Se un nome di file dato con
l'opzione -f contiene un carattere “/”, non viene eseguita nessuna ricerca sul percorso.
La variabile d'ambiente AWKLIBPATH specifica il percorso lungo il quale cercare i file
sorgenti indicati con l'opzione --load. Se questa variabile non esiste, il percorso
predefinito è "/usr/local/lib/gawk" (la directory in questione può variare a seconda di
come gawk è stato compilato e installato).
Gawk esegue i programmi AWK nell'ordine seguente. Per prima cosa, vengono effettuati tutti
gli assegnamenti di variabile indicati dall'opzione -v. Successivamente, gawk compila il
programma in un formato interno. Poi gawk esegue il codice nella regola/e BEGIN (se
esistente/i), quindi procede con la lettura di ciascun file indicato nel vettore ARGV
(fino a ARGV[ARGC-1]). Se non ci sono file indicati nella riga di comando, gawk legge
dallo standard input.
Se un nome di file nella riga di comando ha la forma var=val è trattato come un
assegnamento di variabile. Alla variabile var sarà assegnato il valore val (questo accade
dopo che ogni regola BEGIN è stata eseguita).
Se il valore di un particolare elemento di ARGV è la stringa vuota (""), gawk lo salta.
For each input file, if a BEGINFILE rule exists, gawk executes the associated code before
processing the contents of the file. Similarly, gawk executes the code associated with
ENDFILE rules after processing the file.
Per ogni record in input, gawk controlla se c'è corrispondenza con qualche criterio di
ricerca specificato nel programma AWK. Per ogni criterio di ricerca a cui un record
corrisponde, gawk esegue l'azione associata. I criteri di ricerca sono verificati
nell'ordine in cui appaiono nel programma.
Infine, dopo che sono esauriti i dati in input, gawk esegue il codice nelle regola/e END
(se esistente/i).
Directory nella riga di comando
Secondo POSIX, i file indicati sulla riga di comando di awk devono essere file di testo.
Se non lo sono il comportamento è “indefinito”. La maggior parte delle versioni di awk
considerano una directory sulla riga di comando come un errore fatale.
For gawk, a directory on the command line produces a warning, but is otherwise skipped.
If either of the --posix or --traditional options is given, then gawk reverts to treating
directories on the command line as a fatal error.
VARIABILI, RECORD E CAMPI
AWK variables are dynamic; they come into existence when they are first used. Their
values are either floating-point numbers or strings, or both, depending upon how they are
used. Additionally, gawk allows variables to have regular-expression type. AWK also has
one dimensional arrays; arrays with multiple dimensions may be simulated. However, gawk
provides true arrays of arrays. Several pre-defined variables are set as a program runs;
these are described as needed and summarized below.
Record
Normally, records are separated by newline characters. You can control how records are
separated by assigning values to the built-in variable RS. See
https://www.gnu.org/software/gawk/manual/html_node/Records.html for the details.
Campi
As each input record is read, gawk splits the record into fields, using the value of the
FS variable as the field separator. Additionally, FIELDWIDTHS and FPAT may be used to
control input field splitting. See the details, starting at
https://www.gnu.org/software/gawk/manual/html_node/Fields.html.
Ogni campo nel record in input può essere individuato dalla sua posizione: $1, $2, e così
via. $0 è l'intero record, compresi eventuali spazi bianchi iniziali e finali.
La variabile NF contiene il numero di campi nel record in input.
Riferimenti a campi inesistenti (cioè campi dopo $NF) producono la stringa vuota.
Tuttavia, l'assegnamento ad un campo inesistente (per esempio $(NF+2) = 5) provoca
l'incremento del valore di NF, crea tutti i campi intermedi assegnando loro la stringa
nulla, e fa sì che il valore di $0 sia ricalcolato utilizzando OFS per separare i campi.
Riferimenti a campi con indice negativo producono un errore fatale. Il decremento di NF
provoca la perdita dei campi di indice superiore al valore impostato, ed il ricalcolo di
$0, utilizzando OFS per separare i campi.
L'assegnamento di un valore a un campo esistente provoca la ricostruzione dell'intero
record quando si faccia riferimento a $0. Analogamente, assegnare un valore a $0 provoca
una nuova divisione del record, creando nuovi valori per i suoi campi.
Variabili predefinite
Gawk's built-in variables are listed below. This list is purposely terse. For details,
see https://www.gnu.org/software/gawk/manual/html_node/Built_002din-Variables.
ARGC The number of command line arguments.
ARGIND L'indice in ARGV del file correntemente in elaborazione.
ARGV Vettore degli argomenti della riga di comando. Il vettore è indicizzato da 0
ad ARGC - 1.
BINMODE On non-POSIX systems, specifies use of “binary” mode for all file I/O. See
https://www.gnu.org/software/gawk/manual/html_node/PC-Using.html for the
details.
CONVFMT Il formato di conversione dei numeri, quello predefinito è "%.6g".
ENVIRON Un vettore contenente i valori dell'ambiente corrente. Il vettore è
indicizzato dalle variabili d'ambiente, e ogni elemento è il valore di quella
variabile.
ERRNO Se ha luogo un errore di sistema durante una ridirezione per una getline, o
durante una lettura fatta con getline, oppure in una close(), ERRNO viene
impostato a una stringa che descrive l'errore. Il valore è passibile di
traduzione nelle localizzazioni diverse dall'inglese.
FIELDWIDTHS Una lista di dimensioni di campo separate da spazi. Se impostato, gawk
suddivide l'input secondo campi di larghezza fissa, anziché usare il valore
della variabile FS come separatore di campo. Ogni larghezza di campo può
opzionalmente essere preceduta da un valore, separato da una virgola, che
specifica il numero di caratteri da saltare prima di posizionarsi all'inizio
del campo.
FILENAME Il nome del file di input corrente. Se non sono specificati file nella riga di
comando, il valore di FILENAME è “-”. Tuttavia, FILENAME è indefinito
all'interno della regola BEGIN (a meno che non sia impostato da getline).
FNR Il numero di record corrente del file in input corrente.
FPAT Un'espressione regolare che descrive il contenuto dei campi in un record. Se
impostato, gawk suddivide l'input in campi, dove i campi corrispondono
all'espressione regolare, invece di usare il valore di FS come separatore di
campo.
FS The input field separator, a space by default. See
https://www.gnu.org/software/gawk/manual/html_node/Field-Separators.html for
the details.
FUNCTAB Un vettore i cui indici e i corrispondenti valori sono i nomi di tutte le
funzioni definite dall'utente o funzioni di estensione presenti nel programma.
NOTA: Si può non usare l'istruzione delete applicandola al vettore FUNCTAB.
IGNORECASE Controls the case-sensitivity of all regular expression and string operations.
See
https://www.gnu.org/software/gawk/manual/html_node/Case_002dsensitivity.html
for details.
LINT Provides dynamic control of the --lint option from within an AWK program.
NF Il numero di campi nel record corrente.
NR Il numero totale di record incontrati finora.
OFMT Il formato d'uscita per i numeri, quello predefinito è "%.6g".
OFS Il separatore di campi in uscita, normalmente è uno spazio.
ORS Il separatore di record in uscita, normalmente la sequenza di fine linea
("newline").
PREC La precisione di lavoro di numeri a virgola mobile con precisione arbitraria,
53 [bit] è il valore predefinito.
PROCINFO The elements of this array provide access to information about the running AWK
program. See https://www.gnu.org/software/gawk/manual/html_node/Auto_002dset
for the details.
ROUNDMODE The rounding mode to use for arbitrary precision arithmetic on numbers, by
default "N" (IEEE-754 roundTiesToEven mode). See
https://www.gnu.org/software/gawk/manual/html_node/Setting-the-rounding-mode
for the details.
RS Il separatore di record in input (se non specificato è "newline").
RT Il terminatore di record. Gawk pone RT uguale al testo in input che
corrisponde al carattere o alla espressione regolare indicati in RS.
RSTART The index of the first character matched by match(); 0 if no match.
RLENGTH La lunghezza della stringa trovata da match(); oppure -1 se non ci sono
corrispondenze.
SUBSEP La stringa usata per separare indici multipli negli elementi di un vettore,
quella predefinita è "\034".
SYMTAB An array whose indices are the names of all currently defined global variables
and arrays in the program. You may not use the delete statement with the
SYMTAB array, nor assign to elements with an index that is not a variable
name.
TEXTDOMAIN Il dominio di testo del programma AWK ; usato per trovare le traduzioni
localizzate delle stringhe del programma.
Array
I vettori hanno per indice un'espressione tra parentesi quadre ([ e ]). Se l'espressione è
formata da una lista di espressioni (expr, expr ...) l'indice del vettore è una stringa
ottenuta concatenando i valori (stringa) di ogni espressione, separati dal valore della
variabile SUBSEP. Questa modalità è usata per simulare vettori multidimensionali. Per
esempio:
i = "A"; j = "B"; k = "C"
x[i, j, k] = "hello, world\n"
assegna la stringa "hello, world\n" all'elemento del vettore x che è indicizzato dalla
stringa "A\034B\034C". In AWK, tutti i vettori sono associativi, cioè indicizzati da
valori di tipo stringa.
L'operatore speciale in può essere usato per controllare se un vettore contiene un certo
valore come indice.
if (val in vettore) print vettore[val]
Se il vettore ha indici multipli, si usi (i, j) in vettore.
Il costrutto in può anche essere usato in un ciclo for per iterare su tutti gli elementi
di un vettore. Comunque, il costrutto (i, j) in vettore funziona solo nelle verifiche,
non nei cicli for.
Un elemento di un vettore può essere cancellato con l'istruzione delete. L'istruzione
delete può anche essere usata per cancellare l'intero contenuto di un vettore, basta
specificare il nome del vettore stesso senza indici.
gawk supports true multidimensional arrays. It does not require that such arrays be
“rectangular” as in C or C++. See
https://www.gnu.org/software/gawk/manual/html_node/Arrays for details.
Spazi-dei-nomi
Gawk fornisce una semplice funzionalità, namespace, (spazio-dei-nomi) per ovviare al fatto
che tutte le variabili in AWK sono globali.
Un nome qualificato consiste di due identificativi semplici, congiunti da una coppia di
due punti (::). Il primo dei due identificativi designa lo spazio-dei-nomi (namespace)
mentre il secondo è il nome della variabile al suo interno. Tutti i nomi semplici (non
qualificati) sono considerati come appartenenti allo spazio-dei-nomi “corrente”; lo
spazio-dei-nomi predefinito ha nome awk. Comunque, gli identificativi i cui nomi sono
composti solo da lettere maiuscole, vengono sempre considerati come facenti parte dello
spazio-dei-nomi awk, anche se lo spazio-dei-nomi corrente è diverso da quello predefinito.
Si può cambiare lo spazio-dei-nomi corrente tramite la direttiva @namespace "nome".
The standard predefined builtin function names may not be used as namespace names. The
names of additional functions provided by gawk may be used as namespace names or as simple
identifiers in other namespaces. For more details, see
https://www.gnu.org/software/gawk/manual/html_node/Namespaces.html#Namespaces.
Notazione e conversione delle variabili
Le variabili e i campi possono essere numeri (in virgola mobile), stringhe, o entrambe le
cose. Possono anche essere espressioni regolari. Come sia interpretato il valore di una
variabile dipende dal contesto. In un'espressione numerica, sarà trattato come un numero;
usato come stringa, sarà trattato come tale.
Per far trattare una variabile come numero, le si sommi zero; per ottenere che venga
trattata come come stringa, le si concateni la stringa nulla.
Le variabili non inizializzate hanno sia il valore numerico zero che il valore di stringa
"" (la stringa nulla, o vuota).
Quando una stringa deve essere convertita in un numero, la conversione è compiuta con
strtod(3). I numeri sono convertiti a stringhe usando sprintf(3) col valore di CONVFMT
come stringa di formato ed il valore numerico della variabile come argomento. Tuttavia,
anche se tutti i numeri in AWK sono in virgola mobile ("float"), i valori privi di
decimali sono sempre convertiti in numeri interi.
Gawk esegue i confronti nel modo seguente: Se due variabili sono numeriche, sono
confrontate numericamente. Se una è numerica e l'altra è una stringa interpretabile come
“stringa numerica,” sono pure confrontate numericamente. Negli altri casi, gli eventuali
valori numerici sono convertiti in stringhe, ed è eseguito un confronto tra stringhe.
Ovviamente, due stringhe sono confrontate come stringhe.
Si noti che le costanti stringa, come "57", non sono stringhe numeriche, ma solo costanti
stringa. L'idea di “stringa numerica” si applica solo ai campi, all'input di getline, a
FILENAME, agli elementi di ARGV di ENVIRON, ed agli elementi di un vettore creato da
split() o da patsplit() che abbiano le caratteristiche di una stringa numerica. L'idea
fondamentale è che i dati immessi dall'utente, e solo essi, se risultano essere numerici,
saranno trattati come numeri.
Costanti ottali ed esadecimali
Nel codice sorgente del programma si possono usare costanti ottali ed esadecimali in stile
C. Per esempio, il valore ottale 011 è uguale al decimale 9, e il valore esadecimale 0x11
è uguale al decimale 17.
Costanti di tipo stringa
String constants in AWK are sequences of characters enclosed between double quotes (like
"value"). Within strings, certain escape sequences are recognized, as in C. See
https://www.gnu.org/software/gawk/manual/html_node/Escape-Sequences for the details.
Costanti di tipo Regexp
Una costante di tipo espressione regolare è una sequenza di caratteri racchiusa tra barre
(come /valore/).
The escape sequences described in the manual may also be used inside constant regular
expressions (e.g., /[ \t\f\n\r\v]/ matches whitespace characters).
Gawk consente anche di usare costanti formate da espressioni regolari fortemente
tipizzate. I nome di tali costanti sono preceduti da un simbolo @ (così: @/valore/).
Queste costanti possono essere assegnare a scalari (variabili, elementi di un vettore) e
passate a funzione definite dall'utente. Le variabili il cui valore è stato assegnato in
questo modo hanno come tipo quello di variabili di espressioni regolari.
CRITERI DI RICERCA E AZIONI
AWK è un linguaggio che procede per righe. Il criterio va a inizio riga, l'azione lo
segue. Le istruzioni dell'azione sono racchiuse tra { e }. Sia il criterio che l'azione
possono mancare ma, naturalmente, non entrambi. Se manca il criterio, l'azione è eseguita
per ogni record in input. Omettere invece l'azione equivale a specificare
{ print }
ossia stampare l'intero record.
I commenti cominciano col carattere #, e continuano fino a fine riga. Si possono separare
le istruzioni con righe vuote. Un'istruzione finisce normalmente alla fine della riga, a
meno che non termini con una virgola, {, ?, :, &&, o ||. Anche le istruzioni in righe
terminanti con do o else continuano automaticamente alla riga successiva. Negli altri
casi, un'istruzione può continua sulla riga successiva se termina con “\”, nel qual caso
il "newline" è ignorato. Comunque, un “\” che venga dopo un carattere # non è speciale.
Si possono scrivere più istruzioni sulla stessa riga separandole con “;”. Questo si
applica sia alle istruzioni all'interno di un'azione (il caso più comune), sia ai gruppi
criterio-azione stessi.
Criteri di ricerca
I criteri di ricerca di AWK possono assumere le forme seguenti:
BEGIN
END
BEGINFILE
ENDFILE
/espressione regolare/
espressione di relazione
criterio && criterio
criterio || criterio
criterio ? criterio : criterio
(criterio)
! criterio
criterio1, criterio2
BEGIN e END sono due tipi speciali di criteri di ricerca, che non dipendono dai dati in
input. Le azioni di tutti i criteri di ricerca BEGIN sono unite insieme, come se tutte le
istruzioni fossero scritte in un'unica regola BEGIN, e sono eseguite prima che sia letto
qualsiasi input. Allo stesso modo, tutte le regole END sono fuse insieme, ed eseguite dopo
che tutti i dati in input sono terminati o dopo che si è incontrata l'istruzione exit.
BEGIN e END non possono essere combinati con altri criteri in espressioni di ricerca. I
criteri BEGIN e END devono necessariamente essere seguiti dall'indicazione di un'azione.
BEGINFILE e ENDFILE sono altri criteri speciali le cui azioni sono eseguite prima della
lettura del primo record di ogni file di input richiamato sulla riga di comando, e dopo la
lettura dell'ultimo record di ognuno di questi file. All'interno della regola BEGINFILE,
il valore di ERRNO è una stringa vuota se il file è stato aperto con successo. Altrimenti,
in caso di problemi col file il codice dovrebbe usare nextfile per saltarlo. Se non lo
fa, gawk emette il solito errore fatale per i file che non possono essere aperti.
For /regular expression/ patterns, the associated statement is executed for each input
record that matches the regular expression. Regular expressions are essentially the same
as those in egrep(1). See https://www.gnu.org/software/gawk/manual/html_node/Regexp.html
for the details on regular expressions.
In un'espressione relazionale si può usare qualsiasi operatore definito nella sezione
sulla azioni, più avanti. Generalmente l'espressione relazionale è utilizzata per
verificare se certi campi siano individuati da determinate espressioni regolari.
Gli operatori &&, || e ! sono rispettivamente l'AND logico, l'OR logico e il NOT logico.
Come i loro equivalenti del linguaggio C, sono valutati solo il numero di
operandistrettamente necessario a decidere il risultato, a partire da quello più a
sinistra ("short-circuit evaluation"). Sono usati per combinare espressioni di ricerca
più semplici. Come nella maggior parte dei linguaggi, si possono usare parentesi per
cambiare l'ordine di valutazione.
L'operatore ?: è simile allo stesso operatore in C: se il primo criterio è vero, allora il
criterio utilizzato per il test è il secondo, altrimenti è il terzo. Dei criteri secondo e
terzo, ne è valutato sempre solo uno.
Un'espressione nella forma criterio1, criterio2 è detta criterio intervallo. Essa
individua tutti i record a partire da quello che ha corrispondenza con criterio1, fino a
quello che corrisponde a criterio2, compreso. Non può essere combinata con alcun'altra
espressione.
Azioni
Le istruzioni di azione sono racchiuse tra parentesi graffe, { e }. L'insieme delle
istruzioni di azione è formato dalle solite istruzioni di assegnamento, condizionali e
iterative presenti nella maggior parte dei linguaggi. Gli operatori, le strutture di
controllo e le istruzioni di input/output ricalcano quelli corrispondenti nel linguaggio
C.
Operatori
Gli operatori di AWK, in ordine decrescente di precedenza, sono
(...) Raggruppamento
$ Riferimento a campi.
++ -- Incremento e decremento, sia prefisso che suffisso.
^ Exponentiation.
+ - ! Più e meno unari, e negazione logica.
* / % Moltiplicazione, divisione e resto della divisione.
+ - Addizione e sottrazione.
space Concatenazione di stringhe.
| |& I/O proveniente dall'output di comandi [pipe] per getline, print e printf.
< > <= >= == !=
I normali operatori di relazione.
~ !~ Regular expression match, negated match.
in Controllo di appartenenza a un vettore.
&& AND logico.
|| OR logico.
?: L'espressione condizionale in stile C. Ha la forma espressione1
?espressione2: espressione3. Se espressione1 è vera, il valore
dell'espressione è espressione2, altrimenti è espressione3. Viene calcolata
solo una delle due espressioni espressione2 ed espressione3.
= += -= *= /= %= ^=
Assegnamento. Sono permessi sia l'assegnamento assoluto (var = valore) che
quello con operatore (le altre forme).
Istruzioni di controllo
Le istruzioni di controllo sono le seguenti:
if (condizione) istruzione [ else istruzione ]
while (condizione) istruzione
do istruzione while (condizione)
for (espressione1; espressione2; espressione3) istruzione
for (var in vettore) istruzione
break
continue
delete vettore[indice]
delete vettore
exit [ espressione ]
{ istruzioni }
switch (espressione) { case valore|espressione_regolare : istruzione ... [ default: istruzione ]
}
Istruzioni di I/O
Le istruzioni di input/output sono le seguenti:
close(file [, come]) Close an open file, pipe or coprocess. The optional how should only
be used when closing one end of a two-way pipe to a coprocess. It
must be a string value, either "to" or "from".
getline Imposta $0 usando la successiva riga di input; imposta NF, NR, FNR,
RT.
getline <file Imposta $0 usando la successiva riga di file; imposta NF, RT.
getline variabile Imposta variabile dalla successiva riga di input; imposta NR, FNR,
RT.
getline variabile <file
Imposta variabile dalla successiva riga di file; imposta RT.
comando | getline [variabile]
Esegue comando dirigendo l'output [del comando] o in $0 o in
variabile, come sopra, e RT.
comando |& getline [variabile]
Esegue comando come un coprocesso dirigendo l'output [del comando] o
in $0 o in variabile, come sopra, e RT. (Il comando può anche essere
un socket. Vedere la sottosezione Nomi di file speciali, più
avanti.)
fflush([file]) Scarica il contenuto di tutti i buffer associati ai file o alle pipe
aperti in scrittura file. Se file non è specificato o ha per valore
la stringa nulla, l'operazione è eseguita su tutti i file e le pipe
aperti in scrittura.
next Cessa l'elaborazione della riga di input corrente. Legge la
successiva riga di input, e l'elaborazione ricomincia a partire dal
primo criterio di ricerca del programma AWK. Se non ci sono più
righe in input, gawk esegue i comandi di ogni regola END, se
presenti.
nextfile Cessa l'elaborazione del file di input corrente. La prossima riga
letta proverrà dal file di input successivo. Aggiorna FILENAME e
ARGIND, reimposta FNR a 1, e l'elaborazione riprende dal primo
criterio di ricerca del programma AWK. Se non ci sono più righe in
input, gawk esegue i comandi di ogni regola ENDFILE ed END, se
presenti.
print Stampa il record corrente. Alla fine della riga in output viene
aggiunto il valore della variabile ORS.
print lista-espressioni
Stampa le espressioni indicate. Ogni espressione è separata dal
valore della variabile OFS. La riga prodotta termina col valore
della variabile ORS.
print lista-espressioni >file
Stampa le espressioni indicate su file. Ogni espressione è separata
dal valore della variabile OFS. La riga prodotta termina col valore
della variabile ORS.
printf fmt, lista-espressioni
Format and print.
printf fmt, lista-espressioni >file
Stampa secondo formato su file.
system(riga-di-comando)
Execute the command cmd-line, and return the exit status. (This may
not be available on non-POSIX systems.) See
https://www.gnu.org/software/gawk/manual/html_node/I_002fO-Functions.html#I_002fO-Functions
for the full details on the exit status.
Sono permessi anche altri tipi di ridirezione in scrittura per print e printf.
print ... >> file
Aggiunge l'output alla fine di file.
print ... | comando
Scrive su una pipe.
print ... |& comando
Invia dati a un coprocesso o a un socket. (Vedere anche la sottosezione Nomi di
file speciali, più avanti).
Il comando getline restituisce 1 se tutto va bene, zero in caso di fine file, e -1 in caso
di errore. Se il valore di errno(3) indica che l'operazione di I/O può essere ritentata, e
PROCINFO["input", "RETRY"] è stato impostato, viene restituito il valore -2 invece che -1
e ulteriori chiamate a getline possono essere effettuate. A fronte di un errore ERRNO è
impostato a una stringa che descrive il problema.
NOTA: L'insuccesso nell'apertura di un socket bidirezionale genera un errore non fatale
che viene restituito alla funzione chiamante. Se si sta usando una pipe, un coprocesso, o
un socket per alimentare la getline, o da print o printf all'interno di un ciclo, si deve
usare close() per creare una nuova istanza del comando o del socket. AWK non chiude
automaticamente pipe, socket, o coprocessi quando questi restituiscono EOF.
The AWK versions of the printf statement and sprintf() function are similar to those of C.
For details, see https://www.gnu.org/software/gawk/manual/html_node/Printf.html.
Nomi di file speciali
Effettuando delle ridirezioni di print o printf in un file, o attraverso getline da un
file, gawk riconosce internamente alcuni nomi di file speciali, che permettono di accedere
a descrittori di file già aperti ereditati dal processo genitore di gawk (la shell,
solitamente). Questi nomi di file possono anche essere usati nella riga di comando per
designare dei file di dati. I nomi di file sono:
- Lo standard input.
/dev/stdin Lo standard input.
/dev/stdout Lo standard output.
/dev/stderr Lo standard error in output.
/dev/fd/n Il file associato al descrittore di file aperto n.
I seguenti nomi di file speciali si possono usare con l'operatore |& di coprocesso per
creare connessioni di rete TCP/IP:
/inet/tcp/lport/rhost/rport
/inet4/tcp/lport/rhost/rport
/inet6/tcp/lport/rhost/rport
File per una connessione TCP/IP su una porta locale lport verso un host remoto
rhost sulla porta remota rport. Si usi la porta numero 0 Per permettere al sistema
di scegliere una porta. Si usi /inet4 per richiedere una connessione IPv4, e /inet6
per richiedere una connessione IPv6. Specificando semplicemente /inet usa quello
predefinito del sistema (molto probabilmente IPv4). Si può usare solo con
l'operatore bidirezionale di I/O |&.
/inet/udp/lport/rhost/rport
/inet4/udp/lport/rhost/rport
/inet6/udp/lport/rhost/rport
Come sopra, ma usando porte UDP/IP invece che TCP/IP.
Funzioni numeriche
AWK ha le seguenti funzioni aritmetiche predefinite:
atan2(y, x) Restituisce l'arcotangente di y/x in radianti.
cos(espressione)
Restituisce il coseno di espressione, in radianti.
exp(espressione)
La funzione esponenziale.
int(espressione)
Troncamento a numero intero.
log(espressione)
Logaritmo a base naturale.
rand() Restituisce un numero casuale N, tra zero e uno, tale che 0 ≤ N < 1.
sin(espressione)
Restituisce il seno di espressione, in radianti.
sqrt(espressione)
Restituisce la radice quadrata di espressione.
srand([espressione])
Usa espressione come nuovo seme per il generatore di numeri casuali. Se
espressione non è indicata, sarà utilizzata il tempo corrente, misurato in
secondi dal 1970. Il valore restituito è il valore precedente del seme.
Funzioni di stringa
Gawk has the following built-in string functions; details are provided in
https://www.gnu.org/software/gawk/manual/html_node/String-Functions.
asort(s [, d [, come] ])
Return the number of elements in the source array s. Sort the
contents of s using gawk's normal rules for comparing values, and
replace the indices of the sorted values s with sequential
integers starting with 1. If the optional destination array d is
specified, first duplicate s into d, and then sort d, leaving the
indices of the source array s unchanged. The optional string how
controls the direction and the comparison mode. Valid values for
how are described in
https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions.
s and d are allowed to be the same array; this only makes sense
when supplying the third argument as well.
asorti(s [, d [, come] ])
Return the number of elements in the source array s. The behavior
is the same as that of asort(), except that the array indices are
used for sorting, not the array values. When done, the array is
indexed numerically, and the values are those of the original
indices. The original values are lost; thus provide a second
array if you wish to preserve the original. The purpose of the
optional string how is the same as for asort(). Here too, s and d
are allowed to be the same array; this only makes sense when
supplying the third argument as well.
gensub(r, s, h [, t]) Cerca nella stringa obiettivo t corrispondenze con l'espressione
regolare r. Se h è una stringa che inizia con g o G, tutte le
corrispondenze con r sono sostituite con s. Altrimenti, h è un
numero che indica la particolare corrispondenza con r che si vuole
sostituire. Se t non è specificata, è usato $0 al suo posto.
All'interno del testo di rimpiazzo s si può utilizzare la sequenza
\n, dove n è una cifra tra 1 e 9, per indicare la parte di testo
che corrisponde alla n-esima sottoespressione tra parentesi. La
sequenza \0 rappresenta tutto il testo corrispondente, e così pure
il carattere &. A differenza di sub() e gsub(), la stringa
modificata è restituita come risultato della funzione, e la
stringa obiettivo originale resta inalterata.
gsub(r, s [, t]) For each substring matching the regular expression r in the string
t, substitute the string s, and return the number of
substitutions. If t is not supplied, use $0. An & in the
replacement text is replaced with the text that was actually
matched. Use \& to get a literal &. (This must be typed as
"\\&"; see
https://www.gnu.org/software/gawk/manual/html_node/Gory-Details.html#Gory-Details
for a fuller discussion of the rules for ampersands and
backslashes in the replacement text of sub(), gsub(), and
gensub().)
index(s, t) Restituisce la posizione della stringa t all'interno della stringa
s, o zero se la stringa t non è presente. (Ciò implica che gli
indici di una stringa di caratteri partono da 1.)
length([s]) Return the length of the string s, or the length of $0 if s is not
supplied. With an array argument, length() returns the number of
elements in the array.
match(s, r [, a]) Restituisce la posizione in s in cui ricorre l'espressione
regolare r, oppure zero se r non è presente, e imposta i valori di
RSTART e RLENGTH. Si noti che l'ordine degli argomenti è lo stesso
in uso per l'operatore ~: stringa ~ espressione-regolare. See
https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions
for a description of how the array a is filled if it is provided.
patsplit(s, a [, r [, seps] ])
Suddivide la stringa s nel vettore a e il vettore dei separatori.
seps nell'espressione regolare r, e restituisce il numero dei
campi. I valori di ogni elemento [del vettore] sono le parti di s
che corrispondono a r. Il valore di seps[i] è il separatore (che
potrebbe anche essere la stringa nulla) individuato davanti a
a[i]. Il valore di seps[0] è il separatore iniziale (che potrebbe
anche essere la stringa nulla). Se r è omesso, FPAT viene usato al
suo posto. I vettori a e seps sono svuotati all'inizio
dell'operazione. La suddivisione si comporta come la suddivisione
in campi con FPAT.
split(s, a [, r [, seps] ])
Split the string s into the array a and the separators array seps
on the regular expression r, and return the number of fields. If
r is omitted, FS is used instead. The arrays a and seps are
cleared first. seps[i] is the field separator matched by r
between a[i] and a[i+1]. Splitting behaves identically to field
splitting.
sprintf(fmt, lista-espressioni)
Stampa lista-espressioni secondo quanto specificato dal formato
fmt, e restituisce la stringa risultante.
strtonum(str) Esamina str, e ne restituisce il valore numerico. Se str inizia
con uno 0, è considerato un numero ottale. Se str inizia con uno
0x o 0X, è considerato un numero esadecimale. Altrimenti, viene
interpretato come numero decimale.
sub(r, s [, t]) Si comporta come gsub(), ma è sostituita solo la prima
sottostringa trovata. Viene restituito zero oppure uno.
substr(s, i [, n]) Restituisce una sottostringa, lunga al massimo n-caratteri, di s a
partire dalla posizione i. Se n è omesso, è usato il resto di s.
tolower(str) Restituisce una copia della stringa str, con tutti i caratteri
maiuscoli in str tradotti nei minuscoli corrispondenti. I
caratteri non alfabetici restano invariati.
toupper(str) Restituisce una copia della stringa str, con tutti i caratteri
minuscoli di str tradotti nei maiuscoli corrispondenti. I
caratteri non alfabetici restano invariati.
Gawk gestisce i caratteri multi-byte. Ciò implica che index(), length(), substr() e
match() lavorano in termini di caratteri, non di byte.
Funzioni di tempo
Gawk provides the following functions for obtaining time stamps and formatting them.
Details are provided in https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.
mktime(datespec [, utc-flag])
Turn datespec into a time stamp of the same form as returned by systime(), and
return the result. If utc-flag is present and is non-zero or non-null, the time
is assumed to be in the UTC time zone; otherwise, the time is assumed to be in
the local time zone. If datespec does not contain enough elements or if the
resulting time is out of range, mktime() returns -1. See
https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.html#Time-Functions
for the details of datespec.
strftime([format [, timestamp[, utc-flag]]])
Formatta timestamp secondo quanto specificato in format. Se utc-flag è presente
e diversa da zero o dalla stringa nulla, il risultato è in UTC [ora di
Greenwich], altrimenti il risultato è nell'ora locale. Il timestamp dovrebbe
essere nella forma utilizzata da systime(). Se timestamp è omesso, sono
utilizzate la data e l'ora correnti. Se format è omesso, è assunto un formato
equivalente a quello dell'output del comando date(1). Il formato predefinito è
disponibile in PROCINFO["strftime"]. Vedere le specifiche per la funzione
strftime() in ISO C per i formati di conversione che sono sicuramente
disponibili.
systime() Restituisce l'ora corrente come numero di secondi a partire da: (1970-01-01
00:00:00 UTC sui sistemi POSIX).
Funzioni di manipolazione dei bit
Gawk supplies the following bit manipulation functions. They work by converting
double-precision floating point values to uintmax_t integers, doing the operation, and
then converting the result back to floating point. Passing negative operands to any of
these functions causes a fatal error.
Le funzioni sono:
and(v1, v2 [, ...]) Restituisce il risultato derivante dall'applicazione della funzione
booleana AND bit per bit ai valori degli argomenti della lista degli
argomenti. Gli argomenti devono essere almeno due.
compl(val) Restituisce il complemento bit per bit di val.
lshift(val, contatore)
Restituisce il valore di val, spostato a sinistra di contatore bit.
or(v1, v2 [, ...]) Restituisce il risultato dell'applicare la funzione booleana OR bit
per bit ai valori degli argomenti della lista degli argomenti. Gli
argomenti devono essere almeno due.
rshift(val, contatore)
Restituisce il valore di val, spostato a destra di contatore bit.
xor(v1, v2 [, ...]) Restituisce il risultato derivante dall'applicazione della funzione
booleana XOR bit per bit ai valori degli argomenti della lista degli
argomenti. Gli argomenti devono essere almeno due.
Funzioni di tipo
Le seguenti funzioni forniscono informazioni relative agli argomenti che vengono loro
passati.
isarray(x) Return true if x is an array, false otherwise.
typeof(x) Restituisce una stringa che indica il tipo di x. La stringa sarà una di queste:
"array", "number", "regexp", "string", "strnum", "unassigned" o "undefined".
Funzioni di internazionalizzazione
The following functions may be used from within your AWK program for translating strings
at run-time. For full details, see
https://www.gnu.org/software/gawk/manual/html_node/I18N-Functions.html#I18N-Functions.
bindtextdomain(directory [, dominio])
Specifica la directory in cui gawk cerca i file .gmo, nel caso non si trovino o non
si possano mettere nelle directory “standard”. Restituisce la directory a cui
dominio è “collegato”.
Il valore predefinito per dominio è il valore della variabile TEXTDOMAIN. Se
directory è impostato alla stringa nulla (""), bindtextdomain() restituisce il
collegamento corrente per il dato dominio.
dcgettext(stringa [, dominio [, categoria]])
Restituisce la traduzione della stringa nel dominio di testo dominio per la
categoria di localizzazione categoria. Il valore predefinito per dominio è il
valore corrente della variabile TEXTDOMAIN. Il valore predefinito per categoria è
"LC_MESSAGES".
dcngettext(stringa1, stringa2, numero [, dominio [, categoria]])
Restituisce la forma plurale in uso per numero nella traduzione di stringa1 e
stringa2 nel dominio di testo dominio per la categoria di localizzazione categoria.
Il valore predefinito per dominio è il valore corrente della variabile TEXTDOMAIN.
Il valore predefinito per categoria è "LC_MESSAGES".
Boolean Valued Functions
You can create special Boolean-typed values; see the manual for how they work and why they
exist.
mkbool(espressione)
Based on the boolean value of expression return either a true value or a false
value. True values have numeric value one. False values have numeric value zero.
FUNZIONI DEFINITE DALL'UTENTE
Le funzioni in AWK sono definite in questo modo:
function nome(lista-di-parametri) { istruzioni }
Le funzioni vengono eseguite se chiamate dall'interno di espressioni, presenti sia
all'interno di criteri di ricerca, che all'interno di azioni. I parametri forniti al
momento della chiamata sono sostituiti ai parametri formali dichiarati nella funzione. I
vettori sono passati per riferimento, le altre variabili per valore.
Local variables are declared as extra parameters in the parameter list. The convention is
to separate local variables from real parameters by extra spaces in the parameter list.
For example:
function f(p, q, a, b) # a e b sono variabili locali { ... }
/abc/ { ... ; f(1, 2) ; ... }
The left parenthesis in a function call is required to immediately follow the function
name, without any intervening whitespace. This restriction does not apply to the built-in
functions listed above.
Le funzioni possono chiamare a loro volta altre funzioni, e possono essere ricorsive. I
parametri utilizzati come variabili locali sono inizializzati alla stringa nulla e al
numero zero al momento dell'invocazione.
Si usi return expr per restituire un valore da una funzione. Il valore di ritorno è
indefinito se non si fornisce alcun valore, o se la funzione ritorna automaticamente dopo
aver eseguito l'ultima istruzione della funzione stessa, nella modalità detta “falling
off”.
Functions may be called indirectly. To do this, assign the name of the function to be
called, as a string, to a variable. Then use the variable as if it were the name of a
function, prefixed with an @ sign, like so:
function mia_funzione() { print "mia_funzione è stata chiamata" ... }
{ ... the_func = "mia_funzione" @the_func() # chiamata tramite nome_funzione di mia_funzione ... }
Se è stata data l'opzione --lint, gawk avvertirà in caso di chiamate a funzioni indefinite
al momento della valutazione sintattica del programma anziché durante l'esecuzione. La
chiamata di una funzione indefinita in fase di esecuzione è un errore fatale.
CARICARE DINAMICAMENTE NUOVE FUNZIONI
You can dynamically add new functions written in C or C++ to the running gawk interpreter
with the @load statement. The full details are beyond the scope of this manual page; see
https://www.gnu.org/software/gawk/manual/html_node/Dynamic-Extensions.html#Dynamic-Extensions.
SEGNALI
Il profilo gawk riconosce due segnali. SIGUSR1 provoca la scrittura di un profilo e dello
stack delle chiamate a funzione nel file di profilazione, che ha per nome awkprof.out, o
qualsiasi nome sia stato fornito specificando l'opzione --profile. Poi l'esecuzione del
programma prosegue regolarmente. SIGHUP chiede a gawk di scrivere il profilo e lo stack
delle chiamate a funzione e di terminare l'esecuzione del programma.
INTERNAZIONALIZZAZIONE
Le costanti di tipo stringa sono sequenze di caratteri racchiuse fra doppi apici. In un
ambiente dove non si parla inglese, è possibile segnare delle stringhe in un programma AWK
per richiederne la traduzione nel linguaggio utilizzato in loco. Tali stringhe sono
precedute nel programma AWK da un carattere di sottolineatura (“_”). Per esempio,,
gawk 'BEGIN { print "hello, world" }'
stampa sempre il messaggio hello, world. Ma,
gawk 'BEGIN { print _"hello, world" }'
might print bonjour, monde in France. See
https://www.gnu.org/software/gawk/manual/html_node/Internationalization.html#Internationalization
for the steps involved in producing and running a localizable AWK program.
ESTENSIONI GNU
Gawk has a too-large number of extensions to POSIX awk. They are described in
https://www.gnu.org/software/gawk/manual/html_node/POSIX_002fGNU.html. All the extensions
can be disabled by invoking gawk with the --traditional or --posix options.
VARIABILI D'AMBIENTE
La variabile d'ambiente AWKPATH può essere usata per fornire una lista di directory che
gawk esamina alla ricerca di file coi nomi indicati tramite le opzioni -f, --file, -i e
--include, e tramite la direttiva @include. Se la ricerca iniziale non ha successo, una
seconda ricerca è effettuata accodando .awk al nome del file indicato.
La variabile d'ambiente AWKLIBPATH può essere usata per fornire una lista di directory che
gawk esamina alla ricerca di file coi nomi indicati tramite le opzioni -l e --load.
The GAWK_PERSIST_FILE environment variable, if present, specifies a file to use as the
backing store for persistent memory. This is an experimental feature. See GAWK:
Effective AWK Programming for the details.
La variabile d'ambiente GAWK_READ_TIMEOUT può essere usata per specificare un tempo
massimo in millisecondi per leggere input da un terminale, da una pipe o da una
comunicazione bidirezionale, inclusi i socket.
Per le connessioni a un host remoto via socket, GAWK_SOCK_RETRIES controlla il numero di
tentativi di lettura, e GAWK_MSEC_SLEEP l'intervallo fra un tentativo di lettura e quello
successivo. L'intervallo è in millisecondi. Su sistemi che non supportano usleep(3), il
valore è arrotondato a un numero intero di secondi.
Se la variabile POSIXLY_CORRECT esiste nell'ambiente, gawk si comporta esattamente come se
--posix fosse stato specificato sulla riga di comando. Se --lint è stato specificato, gawk
emette un messaggio di avvertimento riguardo a questo.
STATO DI USCITA
Se l'istruzione exit è usata avendo come parametro un valore, gawk termina restituendo il
valore numerico in questione.
Altrimenti, se non sono stati riscontrati problemi in fase di esecuzione, gawk termina con
il valore della costante C EXIT_SUCCESS. Questo valore è normalmente zero.
In caso di errore, gawk termina con il valore della costante C EXIT_FAILURE. Questo valore
è normalmente uno.
Se gawk termina a causa di un errore fatale, il valore restituito è 2. Su sistemi
non-POSIX, questo valore può essere visualizzato come EXIT_FAILURE.
INFORMAZIONE SULLA VERSIONE
Questa pagina man documenta gawk, versione 5.2.
AUTORI
La versione originale di UNIX awk è stata progettata e implementata da Alfred Aho, Peter
Weinberger, e Brian Kernighan dei Bell Laboratories. Brian Kernighan continua a mantenere
e migliorare il programma.
Paul Rubin e Jay Fenlason, della Free Software Foundation, hanno scritto gawk, in modo che
fosse compatibile con la versione originale di awk distribuita con la Settima Edizione di
UNIX. John Woods ha contribuito con numerose correzioni di errori. David Trueman, con
contribuzioni da Arnold Robbins, ha reso gawk compatibile con la nuova versione di UNIX
awk. Arnold Robbins è il manutentore corrente.
Vedere GAWK: Effective AWK Programming per una lista completa di contributori a gawk e
alla sua documentazione.
Vedere il file README nella distribuzione gawk per informazioni aggiornate riguardo ai
manutentori e per sapere per quali sistemi operativi gawk è disponibile.
NOTIFICA DEI "BUG"
If you find a bug in gawk, please use the gawkbug(1) program to report it.
Full instructions for reporting a bug are provided in
https://www.gnu.org/software/gawk/manual/html_node/Bugs.html. Please carefully read and
follow the instructions given there. This will make bug reporting and resolution much
easier for everyone involved. Really.
BUG
L'opzione -F non è più necessaria, vista la possibilità di assegnare variabili nella riga
di comando; viene mantenuta solo per compatibilità all'indietro.
This manual page is too long; gawk has too many features.
VEDERE ANCHE
egrep(1), sed(1), gawkbug(1), printf(3), and strftime(3).
The AWK Programming Language, Alfred V. Aho, Brian W. Kernighan, Peter J. Weinberger,
Addison-Wesley, 1988. ISBN 0-201-07981-X.
GAWK: Effective AWK Programming, Edizione 5.2, disponibile con il codice sorgente gawk. La
versione originale corrente di questo documento è disponibile online a:
https://www.gnu.org/software/gawk/manual.
La documentazione di gettext GNU è disponibile online a:
https://www.gnu.org/software/gettext.
ESEMPI
Stampa ed ordina i nomi di login di tutti gli utenti:
BEGIN { FS = ":" } { print $1 | "sort" }
Conta le righe di un file:
{ nlines++ } END { print nlines }
Aggiunge il numero di riga all'inizio di ogni riga del file:
{ print FNR, $0 }
Concatena e aggiunge numerazione (variazione sul tema):
{ print NR, $0 }
Esegui un comando esterno per alcune linee di dati:
tail -f access_log | awk '/myhome.html/ { system("nmap " $1 ">> logdir/myhome.html") }'
COPYING PERMISSIONS
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 Free Software Foundation, Inc.
È permesso stampare e distribuire copie letterali di questa pagina di manuale, a patto che
il copyright e questa nota di autorizzazione siano conservate e presenti in ogni copia.
È permesso copiare e distribuire versioni modificate di questa pagina del manuale, sotto
le condizioni poste per la copia letterale, a patto che l'intero lavoro derivato sia
distribuito secondo permessi di stampa identici a questi.
È permesso copiare e distribuire traduzioni di questa pagina dimanuale in un'altra lingua,
sotto le condizioni poste sopra per leversioni modificate, salvo che quest'informazione
suipermessi di copia e ristampa deve essere espressa in una traduzioneapprovata dalla Free
Software Foundation.
TRADUZIONE
La traduzione italiana di questa pagina di manuale è stata creata da Giuseppe Guerrini
<giusguerrini@racine.ra.it>, Antonio Giovanni Colombo <azc100@gmail.com> e Marco Curreli
<marcocurreli@tiscali.it>
Questa traduzione è documentazione libera; leggere la GNU General Public License Versione
3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o successiva per le condizioni di copyright.
Non ci assumiamo alcuna responsabilità.
Per segnalare errori nella traduzione di questa pagina di manuale inviare un messaggio a
⟨pluto-ildp@lists.pluto.it⟩.