gawk - Online nel cloud

PROGRAMMA:

NOME

gawk - linguaggio di scansione ed elaborazione dei modelli

SINOSSI

guardare con aria sciocca [Opzioni di stile POSIX o GNU] -f file-programma [ -- ] file ...
guardare con aria sciocca [ Opzioni di stile POSIX o GNU ] [ -- ] programma-testo file ...

DESCRIZIONE

allocco è l'implementazione del linguaggio di programmazione AWK da parte del Progetto GNU. È conforme a
la definizione del linguaggio nello Standard POSIX 1003.1. Questa versione a sua volta è
in base alla descrizione in I AWK Programmazione Lingua, di Aho, Kernighan e
Weinberger. allocco fornisce le funzionalità aggiuntive che si trovano nella versione corrente di Brian
di Kernighan awk e una serie di estensioni specifiche di GNU.

La riga di comando è composta da opzioni per guardare con aria sciocca stesso, il testo del programma AWK (se non fornito
tramite -f or --file opzioni) e i valori da rendere disponibili nel ARGC ed ARGV pre-
variabili AWK definite.

Quando guardare con aria sciocca viene invocato con il --profilo opzione, inizia a raccogliere statistiche di profilazione
dall'esecuzione del programma. allocco funziona più lentamente in questa modalità e automaticamente
produce un profilo di esecuzione nel file awkprof.out quando fatto. Vedi il --profilo
opzione, di seguito.

allocco ha anche un debugger integrato. Una sessione di debug interattiva può essere avviata da
fornendo il - debug opzione alla riga di comando. In questa modalità di esecuzione, guardare con aria sciocca carichi
il codice sorgente AWK e quindi richiede i comandi di debug. allocco può solo eseguire il debug di AWK
sorgente del programma fornita con il -f opzione. Il debugger è documentato in GAWK: Efficace
AWK Programmazione.

OPZIONE FORMATO

allocco le opzioni possono essere opzioni di una lettera in stile POSIX tradizionale o lunghe in stile GNU
opzioni. Le opzioni POSIX iniziano con un singolo "-", mentre le opzioni lunghe iniziano con "--". Lungo
le opzioni sono fornite sia per le funzionalità specifiche di GNU che per le funzionalità richieste da POSIX.

alloccole opzioni specifiche sono in genere utilizzate in forma di opzioni lunghe. Argomenti per opzioni lunghe
sono uniti con l'opzione da an = segno, senza spazi intermedi, o possono essere
fornito nel successivo argomento della riga di comando. Le opzioni lunghe possono essere abbreviate, purché
l'abbreviazione rimane unica.

Inoltre, ogni opzione lunga ha un'opzione corta corrispondente, in modo che l'opzione sia
la funzionalità può essere utilizzata dall'interno #! script eseguibili.

VERSIONI

allocco accetta le seguenti opzioni. Le opzioni standard sono elencate per prime, seguite da
opzioni per guardare con aria sciocca estensioni, elencate in ordine alfabetico per opzione breve.

-f file-programma
--file file-programma
Leggi il sorgente del programma AWK dal file file-programma, invece che dal primo
argomento della riga di comando. multiplo -f (o --file) possono essere utilizzate opzioni.

-F fs
--separatore di campo fs
Usa il fs per il separatore del campo di input (il valore di FS variabile predefinita).

-v var=val
--assegnare var=val
Assegna il valore val alla variabile var, prima che inizi l'esecuzione del programma.
Tali valori variabili sono disponibili per il INIZIO regola di un programma AWK.

-b
--caratteri-come-byte
Tratta tutti i dati di input come caratteri a byte singolo. In altre parole, non pagare nulla
attenzione alle informazioni sulla localizzazione quando si tenta di elaborare le stringhe come multibyte
personaggi. Il --posix opzione sovrascrive questa.

-c
--tradizionale
Correre in compatibilità modalità. In modalità compatibilità, guardare con aria sciocca si comporta in modo identico a
di Brian Kernighan awk; nessuna delle estensioni specifiche di GNU è riconosciuta. Vedere GNU
ESTENSIONI, di seguito, per maggiori informazioni.

-C
--diritto d'autore
Stampa la versione breve del messaggio di informazione sul copyright GNU sullo standard
l'output e l'uscita con successo.

-d[filetto]
--variabili-dump[=filetto]
Stampa un elenco ordinato di variabili globali, i loro tipi e i valori finali su filetto. Se
no filetto è fornito, guardare con aria sciocca usa un file chiamato awkvars.out nella directory corrente.
Avere un elenco di tutte le variabili globali è un buon modo per cercare caratteri tipografici
errori nei tuoi programmi Useresti anche questa opzione se hai un grande
programma con molte funzioni e vuoi essere sicuro che le tue funzioni no
utilizzare inavvertitamente variabili globali che intendevi essere locali. (Questo è un
errore particolarmente facile da fare con nomi di variabili semplici come i, j, e così via.)

-D[filetto]
- debug[=filetto]
Abilita il debug dei programmi AWK. Per impostazione predefinita, il debugger legge i comandi
interattivamente dalla tastiera (input standard). L'opzionale filetto argomento
specifica un file con un elenco di comandi che il debugger deve eseguire non
in modo interattivo.

-e programma-testo
--fonte programma-testo
Usa il programma-testo come codice sorgente del programma AWK. Questa opzione consente il facile
mescolanza di funzioni di libreria (utilizzate tramite il -f ed --file opzioni) con sorgente
codice inserito nella riga di comando. È inteso principalmente per AWK medium di medie e grandi dimensioni
programmi utilizzati negli script di shell.

-E filetto
--esecuz filetto
Simile a -f, tuttavia, questa opzione è l'ultima elaborata. Questo dovrebbe essere
utilizzato con #! script, in particolare per le applicazioni CGI, per evitare il passaggio
opzioni o codice sorgente (!) sulla riga di comando da un URL. Questa opzione disabilita
assegnazioni di variabili da riga di comando.

-g
--gen-pot
Scansiona e analizza il programma AWK e genera un GNU .pentola (Modello oggetto portatile)
file di formato sullo standard output con voci per tutte le stringhe localizzabili nel
programma. Il programma stesso non viene eseguito. Vedi il GNU gettext distribuzione per
maggiori informazioni su .pentola File.

-h
--Aiuto Stampa un riepilogo relativamente breve delle opzioni disponibili sullo standard output.
(Per il GNU codifica Internazionali, queste opzioni causano un'uscita immediata e riuscita.)

-i include-file
--includere include-file
Carica una libreria di sorgenti awk. Questo cerca la libreria usando il PERCORSO IMPERDIBILE
variabile d'ambiente. Se la ricerca iniziale fallisce, verrà effettuato un altro tentativo
dopo aver aggiunto il .accidenti suffisso. Il file verrà caricato solo una volta (es.
i duplicati vengono eliminati), e il codice non costituisce il programma principale
fonte.

-l lib
--carico lib
Carica una libreria condivisa lib. Questo cerca la libreria usando il AWKLIBPATH
variabile d'ambiente. Se la ricerca iniziale fallisce, verrà effettuato un altro tentativo
dopo aver aggiunto il suffisso della libreria condivisa predefinita per la piattaforma. La Biblioteca
la routine di inizializzazione dovrebbe essere nominata dl_load().

-L [APPREZZIAMO]
--pelucchi[=APPREZZIAMO]
Fornire avvisi su costrutti dubbi o non trasferibili ad altri AWK
implementazioni. Con un argomento opzionale di fatale, gli avvertimenti sui pelucchi diventano fatali
errori. Questo può essere drastico, ma il suo uso incoraggerà sicuramente lo sviluppo
di programmi AWK più puliti. Con un argomento opzionale di invalido, solo avvertimenti su
le cose che sono effettivamente non valide vengono emesse. (Questo non è ancora completamente implementato.)

-M
--bignum
Forza aritmetica di precisione arbitraria sui numeri. Questa opzione non ha effetto se guardare con aria sciocca
non è compilato per utilizzare le librerie GNU MPFR e MP.

-n
--dati-non-decimali
Riconoscere i valori ottali ed esadecimali nei dati di input. Usa il questo opzione con grande
attenzione!

-N
--use-lc-numerico
Questo forze guardare con aria sciocca per utilizzare il carattere del punto decimale della locale durante l'analisi dell'input
dati. Sebbene lo standard POSIX richieda questo comportamento e guardare con aria sciocca lo fa quando
--posix è in effetti, l'impostazione predefinita è seguire il comportamento tradizionale e utilizzare a
punto come punto decimale, anche nelle impostazioni locali in cui il punto non è il decimale
carattere puntiforme. Questa opzione sovrascrive il comportamento predefinito, senza il pieno
rigore draconiano della --posix opzione.

-o[filetto]
--prettyprint[=filetto]
Stampa una bella versione stampata del programma su filetto. Se no filetto è fornito,
guardare con aria sciocca usa un file chiamato awkprof.out nella directory corrente.

-O
--ottimizzare
Abilita ottimizzazioni sulla rappresentazione interna del programma. Attualmente,
questo include il semplice ripiegamento costante e l'eliminazione del richiamo di coda per ricorsivo
funzioni. Il guardare con aria sciocca il manutentore spera di aggiungere ulteriori ottimizzazioni nel tempo.

-p[file-prof]
--profilo[=file-prof]
Avvia una sessione di profilazione e invia i dati di profilazione a file-prof. Il predefinito
is awkprof.out. Il profilo contiene i conteggi di esecuzione di ogni istruzione nel
programma nel margine sinistro e conteggio delle chiamate di funzione per ciascuna funzione definita dall'utente.

-P
--posix
Questo si accende compatibilità modalità, con le seguenti limitazioni aggiuntive:

· \x le sequenze di escape non vengono riconosciute.

· Solo lo spazio e il tab fungono da separatori di campo quando FS è impostato su un singolo spazio,
newline no.

· Non è possibile continuare le righe dopo ? ed :.

· Il sinonimo func per la parola chiave function non è riconosciuto.

· Gli operatori ** ed ** = non può essere utilizzato al posto di ^ ed ^=.

-r
--re-intervallo
Abilita l'uso di intervallo espressioni nella corrispondenza delle espressioni regolari (vedi Regolare
Espressioni, sotto). Le espressioni di intervallo non erano tradizionalmente disponibili nel
Linguaggio AWK. Lo standard POSIX li ha aggiunti, per rendere awk ed egrep coerente con
l'un l'altro. Sono abilitati per impostazione predefinita, ma questa opzione rimane utilizzabile con
--tradizionale.

-S
--sabbia
Esegue guardare con aria sciocca in modalità sandbox, disabilitando il sistema() funzione, reindirizzamento dell'input con
getline, reindirizzamento dell'output con stampare ed printfe il caricamento di estensioni dinamiche.
Anche l'esecuzione del comando (tramite pipeline) è disabilitata. Questo blocca efficacemente a
script dall'accesso alle risorse locali (eccetto per i file specificati nel
riga di comando).

-t
--lint-vecchio
Fornire avvisi sui costrutti che non sono portabili nella versione originale di
UNIX awk.

-V
--versione
Stampa le informazioni sulla versione per questa particolare copia di guardare con aria sciocca sull'uscita standard.
Questo è utile principalmente per sapere se la copia corrente di guardare con aria sciocca sul tuo sistema è attivo
fino ad oggi rispetto a qualunque cosa la Free Software Foundation stia distribuendo.
Questo è utile anche quando si segnalano bug. (Per il GNU codifica Internazionali, Queste
opzioni causano un'uscita immediata e di successo.)

-- Segnala la fine delle opzioni. Questo è utile per consentire ulteriori argomenti all'AWK
programma stesso per iniziare con un "-". Ciò fornisce coerenza con l'argomento
convenzione di analisi utilizzata dalla maggior parte degli altri programmi POSIX.

In modalità compatibilità, tutte le altre opzioni sono contrassegnate come non valide, ma lo sono per il resto
ignorato. Nel funzionamento normale, finché è stato fornito il testo del programma, opzioni sconosciute
vengono trasmessi al programma AWK nel ARGV matrice per l'elaborazione. Questo è particolarmente
utile per eseguire programmi AWK tramite il tasto "#!" meccanismo di interprete eseguibile.

Per la compatibilità POSIX, il -W può essere utilizzata l'opzione, seguita dal nome di un'opzione lunga.

AWK PROGRAMMA ESECUZIONE

Un programma AWK consiste in una sequenza di istruzioni pattern-action e funzioni opzionali
definizioni.

@includere "Nome del file"
@carico "Nome del file"
modello { azione dichiarazioni }
function Nome(parametro stratagemma) { dichiarazioni }

allocco prima legge il sorgente del programma dal file-programma(s) se specificato, da argomenti
a --fonteo dal primo argomento non di opzione sulla riga di comando. Il -f ed
--fonte le opzioni possono essere utilizzate più volte sulla riga di comando. allocco legge il programma
testo come se tutti i file-programmas e i testi sorgente della riga di comando erano stati concatenati
insieme. Questo è utile per creare librerie di funzioni AWK, senza doverlo fare
includerli in ogni nuovo programma AWK che li utilizza. Fornisce anche la possibilità di mescolare
funzioni di libreria con programmi a riga di comando.

Inoltre, le righe che iniziano con @includere può essere usato per includere altri file sorgente in
il tuo programma, rendendo l'uso della libreria ancora più semplice. Questo è equivalente a usare il -i opzione.

Righe che iniziano con @carico può essere usato per caricare librerie condivise nel tuo programma. Questo
è equivalente a usare il -l opzione.

La variabile d'ambiente PERCORSO IMPERDIBILE specifica un percorso di ricerca da utilizzare quando si trovano i file di origine
chiamato con il -f ed -i opzioni. Se questa variabile non esiste, il percorso predefinito è
".:/usr/local/share/awk". (La directory effettiva può variare, a seconda di come guardare con aria sciocca Prima
compilato e installato.) Se un nome di file dato al -f l'opzione contiene un carattere "/", no
viene eseguita la ricerca del percorso.

La variabile d'ambiente AWKLIBPATH specifica un percorso di ricerca da utilizzare quando si trova la fonte
file denominati con il -l opzione. Se questa variabile non esiste, il percorso predefinito è
"/usr/local/lib/gawk". (La directory effettiva può variare, a seconda di come guardare con aria sciocca fu costruito
e installato.)

allocco esegue i programmi AWK nel seguente ordine. Innanzitutto, tutte le assegnazioni di variabili
specificato tramite il -v opzione vengono eseguite. Prossimo, guardare con aria sciocca compila il programma in an
forma interna. Quindi, guardare con aria sciocca esegue il codice nel INIZIO regola(e) (se presente), e poi
procede alla lettura di ogni file nominato nel ARGV matrice (fino a ARGV[ARGC]). Se non ci sono
file nominati sulla riga di comando, guardare con aria sciocca legge l'input standard.

Se un nome file sulla riga di comando ha la forma var=val è trattata come una variabile
Incarico. La variabile var verrà assegnato il valore val. (Questo succede dopo qualsiasi
INIZIO regole sono state eseguite.) L'assegnazione della variabile della riga di comando è molto utile per
assegnazione dinamica dei valori alle variabili utilizzate da AWK per controllare come viene suddiviso l'input
campi e record. È anche utile per controllare lo stato se sono necessari più passaggi
su un singolo file di dati.

Se il valore di un particolare elemento di ARGV è vuoto (""), guardare con aria sciocca lo salta sopra.

Per ogni file di input, se a INIZIARE la regola esiste, guardare con aria sciocca esegue prima il codice associato
elaborare il contenuto del file. Allo stesso modo, guardare con aria sciocca esegue il codice associato a
END FILE dopo aver elaborato il file.

Per ogni record in ingresso, guardare con aria sciocca test per vedere se corrisponde a qualcuno modello nell'AWK
programma. Per ogni modello che il record corrisponde, guardare con aria sciocca esegue l'associato azione.
I modelli vengono testati nell'ordine in cui si verificano nel programma.

Infine, dopo che tutto l'input è esaurito, guardare con aria sciocca esegue il codice nel FINE regola/e (se
qualunque).

Comando linea Directory
Secondo POSIX, i file nominati sul awk la riga di comando deve essere file di testo. Il comportamento
è ``undefined'' se non lo sono. La maggior parte delle versioni di awk trattare una directory al comando
riga come un errore fatale.

A partire dalla versione 4.0 di guardare con aria sciocca, una directory sulla riga di comando produce un avviso, ma
è altrimenti saltato. Se uno dei --posix or --tradizionale le opzioni sono date, allora
guardare con aria sciocca torna a trattare le directory sulla riga di comando come un errore fatale.

VARIABILI, RECORDS E CAMPI

Le variabili AWK sono dinamiche; vengono in esistenza quando vengono utilizzati per la prima volta. I loro
i valori sono numeri in virgola mobile o stringhe, o entrambi, a seconda di come sono
Usato. AWK ha anche array unidimensionali; gli array con più dimensioni possono essere
simulato. allocco fornisce veri array di array; vedere Array, sotto. Diversi predefiniti
le variabili vengono impostate durante l'esecuzione di un programma; questi sono descritti come necessario e riassunti di seguito.

Records
Normalmente, i record sono separati da caratteri di nuova riga. Puoi controllare come sono i record
separati assegnando valori alla variabile incorporata RS. Se RS è un singolo carattere,
quel carattere separa i record. Altrimenti, RS è un'espressione regolare. Testo in
l'input che corrisponde a questa espressione regolare separa il record. Tuttavia, in
modalità di compatibilità, per la separazione viene utilizzato solo il primo carattere del suo valore di stringa
record. Se RS è impostato sulla stringa nulla, quindi i record sono separati da righe vuote.
Quando RS è impostato sulla stringa nulla, il carattere di nuova riga funge sempre da separatore di campo,
oltre a qualunque valore FS potrebbe avere.

campi
Quando ogni record di input viene letto, guardare con aria sciocca divide il record in campi, usando il valore di
FS variabile come separatore di campo. Se FS è un singolo carattere, i campi sono separati da
quel personaggio. Se FS è la stringa nulla, quindi ogni singolo carattere diventa a
campo separato. Altrimenti, FS dovrebbe essere un'espressione regolare completa. Nel
caso speciale che FS è un singolo spazio, i campi sono separati da sequenze di spazi e/o tab
e/o nuove righe. (Ma vedi la sezione POSIX COMPATIBILITA ', sotto). NOTA: Il valore di
IGNORECASO (vedi sotto) influenza anche il modo in cui i campi vengono divisi quando FS è un'espressione regolare,
e come vengono separati i record quando RS è un'espressione regolare.

Se l' LARGHEZZA DI CAMPO variabile è impostato su un elenco di numeri separati da spazi, ogni campo è
dovrebbe avere una larghezza fissa, e guardare con aria sciocca suddivide il record utilizzando le larghezze specificate.
Il valore di FS viene ignorato. Assegnare un nuovo valore a FS or FPAT prevale sull'uso di
LARGHEZZA DI CAMPO.

Allo stesso modo, se il file FPAT variabile è impostata su una stringa che rappresenta un'espressione regolare, ciascuna
campo è costituito da testo che corrisponde a quell'espressione regolare. In questo caso, il normale
espressione descrive i campi stessi, invece del testo che separa i campi.
Assegnare un nuovo valore a FS or LARGHEZZA DI CAMPO prevale sull'uso di FPAT.

Ogni campo nel record di input può essere referenziato dalla sua posizione: $1, $2, E così via. $0
è l'intero record. I campi non devono essere referenziati da costanti:

n = 5
stampare $n

stampa il quinto campo nel record di input.

La variabile NF è impostato sul numero totale di campi nel record di input.

Riferimenti a campi inesistenti (cioè campi dopo $ NF) producono la stringa nulla.
Tuttavia, l'assegnazione a un campo inesistente (es. $(NF+2) = 5) aumenta il valore di NF,
crea eventuali campi intermedi con la stringa nulla come loro valori e causa il valore
of $0 da ricalcolare, con i campi separati dal valore di UST. Riferimenti
a campi numerati negativi causano un errore irreversibile. decrescente NF provoca i valori di
campi oltre il nuovo valore da perdere e il valore di $0 da ricalcolare, con il
campi separati dal valore di UST.

L'assegnazione di un valore a un campo esistente provoca la ricostruzione dell'intero record quando $0 is
referenziato. Allo stesso modo, assegnando un valore a $0 fa sì che il record venga nuovamente diviso, creando
nuovi valori per i campi.

Built-in Variabili
alloccole variabili integrate di sono:

ARGC Il numero di argomenti della riga di comando (non include le opzioni per guardare con aria scioccao
sorgente del programma).

ARGINDO L'indice in ARGV del file in corso di elaborazione.

ARGV Array di argomenti della riga di comando. L'array è indicizzato da 0 a ARGC - 1.
Modifica dinamica del contenuto di ARGV può controllare i file utilizzati per i dati.

MODALITÀ BIN Sui sistemi non POSIX, specifica l'uso della modalità "binaria" per tutti i file I/O.
I valori numerici di 1, 2 o 3, specificano che file di input, file di output o tutti
i file, rispettivamente, dovrebbero usare l'I/O binario. Valori stringa di "R", o "w"
specifica che i file di input o i file di output, rispettivamente, dovrebbero usare binario
I/O. Valori stringa di "rw" or "wr" specifica che tutti i file dovrebbero usare binario
I/O. Qualsiasi altro valore di stringa viene trattato come "rw", ma genera un avviso
messaggio.

CONVFMT Il formato di conversione per i numeri, "%.6g", per impostazione predefinita.

AMBIENTE Un array contenente i valori dell'ambiente corrente. L'array è
indicizzato dalle variabili d'ambiente, ogni elemento essendo il valore di quello
variabile (es. AMBIENTE["CASA"] può essere "/casa/arnold"). Cambiare questo array
non influisce sull'ambiente visto dai programmi che guardare con aria sciocca genera via
reindirizzamento o il sistema() funzione.

ERRORE Se si verifica un errore di sistema eseguendo un reindirizzamento per getline, durante una lettura
per getline, o durante a vicino(), poi ERRORE conterrà una stringa che descrive
l'errore. Il valore è soggetto a traduzione in lingue diverse dall'inglese.

LARGHEZZA DI CAMPO Un elenco separato da spazi di larghezze di campo. Quando impostato, guardare con aria sciocca analizza l'input
in campi di larghezza fissa, invece di utilizzare il valore di FS variabile come
il separatore di campo. Vedere campi, sopra.

NOME DEL FILE Il nome del file di input corrente. Se non vengono specificati file nel comando
linea, il valore di NOME DEL FILE è "-". Però, NOME DEL FILE è indefinito all'interno di
INIZIO regola (a meno che non sia impostata da getline).

FNR Il numero di record di input nel file di input corrente.

FPAT Un'espressione regolare che descrive il contenuto dei campi in un record. quando
impostato, guardare con aria sciocca analizza l'input in campi, dove i campi corrispondono al normale
espressione, invece di usare il valore di FS variabile come il campo
separatore. Vedere campi, sopra.

FS Il separatore del campo di input, uno spazio per impostazione predefinita. Vedere campi, sopra.

FUNZIONETAB Un array i cui indici e valori corrispondenti sono i nomi di tutti gli utenti
funzioni definite o di estensione nel programma. NOTA: Non puoi usare il
delete dichiarazione con il FUNZIONETAB Vettore.

IGNORECASO Controlla la distinzione tra maiuscole e minuscole di tutte le espressioni regolari e le operazioni sulle stringhe.
If IGNORECASO ha un valore diverso da zero, quindi confronti di stringhe e pattern
corrispondenza nelle regole, suddivisione dei campi con FS ed FPAT, record che separa con
RS, espressione regolare che corrisponde a ~ ed !~, e il gensub(), gsub(),
indice(), incontro(), patsplit(), Diviso()e sub() tutte le funzioni integrate ignorano
caso quando si eseguono operazioni con espressioni regolari. NOTA: La sottoscrizione dell'array è
non ricercato. in ogni caso, il assortire() ed assortiti() le funzioni sono interessate.
Quindi, se IGNORECASO non è uguale a zero, /ab/ corrisponde a tutte le stringhe
"ab", "aB", "Ab"e "AB". Come con tutte le variabili AWK, il valore iniziale di
IGNORECASO è zero, quindi tutte le espressioni regolari e le operazioni sulle stringhe sono
normalmente distinzione tra maiuscole e minuscole.

LINT Fornisce il controllo dinamico del --pelucchi opzione all'interno di un programma AWK.
Quando è vero, guardare con aria sciocca stampa avvisi di lanugine. Quando falso, non lo fa. Quando assegnato
il valore della stringa "fatale", gli avvisi di lanugine diventano errori fatali, esattamente come
--lint=fatale. Qualsiasi altro valore vero stampa solo avvisi.

NF Il numero di campi nel record di input corrente.

NR Il numero totale di record di input visti finora.

OFMT Il formato di output per i numeri, "%.6g", per impostazione predefinita.

UST Il separatore del campo di output, uno spazio per impostazione predefinita.

TORI Il separatore di record di output, per impostazione predefinita una nuova riga.

PREC La precisione di lavoro dei numeri in virgola mobile di precisione arbitraria, 53 by
predefinito.

PROCINFO Gli elementi di questo array forniscono accesso alle informazioni sull'esecuzione di AWK
programma. Su alcuni sistemi, potrebbero esserci elementi nell'array, "gruppo 1"
attraverso "gruppon" per alcuni n, che è il numero di gruppi supplementari che
il processo ha. Utilizzare il in operatore per verificare questi elementi. Il
è garantita la disponibilità dei seguenti elementi:

PROCINFO["egid"] Il valore del getegido(2) chiamata di sistema.

PROCINFO["strftime"]
La stringa di formato dell'ora predefinita per strftime().

PROCINFO["euid"] Il valore del geteuid(2) chiamata di sistema.

PROCINFO["FS"] "FS" se il campo si divide con FS è in vigore, "FPAT" if
suddivisione del campo con FPAT è in vigore, o "AMPIEZZA CAMPO"
se il campo si divide con LARGHEZZA DI CAMPO è in vigore.

PROCINFO["identificatori"]
Un sottoarray, indicizzato dai nomi di tutti gli identificatori utilizzati
nel testo del programma AWK. I valori indicano cosa
guardare con aria sciocca conosce gli identificatori dopo che è finito
analizzare il programma; loro sono non aggiornato mentre il
il programma viene eseguito. Per ogni identificatore, il valore di
elemento è uno dei seguenti:

"Vettore"
L'identificatore è un array.

"incorporato"
L'identificatore è una funzione incorporata.

"estensione"
L'identificatore è una funzione di estensione caricata tramite
@carico or -l.

"scalare"
L'identificatore è uno scalare.

"non digitato"
L'identificatore non è digitato (potrebbe essere usato come a
scalare o array, guardare con aria sciocca non lo sa ancora).

"utente" L'identificatore è una funzione definita dall'utente.

PROCINFO["gid"] Il valore del impazzisci(2) chiamata di sistema.

PROCINFO["pgrpid"] L'ID del gruppo di processi del processo corrente.

PROCINFO["pid"] L'ID del processo corrente.

PROCINFO["pid"] L'ID del processo padre del processo corrente.

PROCINFO["uid"] Il valore del getuid(2) chiamata di sistema.

PROCINFO["ordinato_in"]
Se questo elemento esiste in PROCINFO, quindi il suo valore
controlla l'ordine in cui vengono attraversati gli elementi dell'array
in per loop. I valori supportati sono "@ind_str_asc",
"@ind_num_asc", "@val_type_asc", "@val_str_asc",
"@val_num_asc", "@ind_str_desc", "@ind_num_desc",
"@val_type_desc", "@val_str_desc", "@val_num_desc"e
"@non ordinato". Il valore può anche essere il nome di any
funzione di confronto definita come segue:

function cmp_func(i1, v1, i2, v2)

where i1 ed i2 sono gli indici, e v1 ed v2 sono la
valori corrispondenti dei due elementi che vengono confrontati.
Dovrebbe restituire un numero minore, uguale o maggiore
di 0, a seconda di come devono essere gli elementi dell'array
essere ordinato.

PROCINFO["input", "READ_TIMEOUT"]
Il timeout in millisecondi per la lettura dei dati da ingresso,
where ingresso è una stringa di reindirizzamento o un nome di file. Un valore
di zero o minore di zero significa nessun timeout.

PROCINFO["versione_mpfr"]
La versione della libreria GNU MPFR usata per arbitrario
supporto del numero di precisione in guardare con aria sciocca. Questa voce non è
presente se il supporto MPFR non è compilato in guardare con aria sciocca.

PROCINFO["versione_gmp"]
La versione della libreria GNU MP usata per arbitrario
supporto del numero di precisione in guardare con aria sciocca. Questa voce non è
presente se il supporto MPFR non è compilato in guardare con aria sciocca.

PROCINFO["prec_max"]
La massima precisione supportata dalla libreria GNU MPFR
per numeri a virgola mobile di precisione arbitraria. Questo
la voce non è presente se il supporto MPFR non è compilato in
guardare con aria sciocca.

PROCINFO["prec_min"]
La precisione minima consentita dalla libreria GNU MPFR per
numeri in virgola mobile di precisione arbitraria. Questa voce è
non presente se il supporto MPFR non è compilato in guardare con aria sciocca.

PROCINFO["api_major"]
La versione principale dell'API di estensione. Questa voce non è
presente se il caricamento delle estensioni dinamiche non è disponibile.

PROCINFO["api_minor"]
La versione secondaria dell'API di estensione. Questa voce non è
presente se il caricamento delle estensioni dinamiche non è disponibile.

PROCINFO["versione"] la versione di guardare con aria sciocca.

MODALITÀ ROUND La modalità di arrotondamento da utilizzare per l'aritmetica di precisione arbitraria sui numeri, di
difetto "N" (modalità IEEE-754 roundTiesToEven). I valori accettati sono "N" or
"n" per roundTiesToEven, "U" or "tu" per roundVersoPositivo, "D" or "d" per
roundVerso negativo, "Z" or "Insieme a" per roundTowardZero, e se la tua versione di
La libreria GNU MPFR lo supporta, "A" or "un" per roundTiesToAway.

RS Il separatore di record di input, per impostazione predefinita una nuova riga.

RT Il terminatore di record. allocco set RT al testo di input che corrispondeva a
carattere o espressione regolare specificata da RS.

RIAVVIA L'indice del primo carattere abbinato da incontro(); 0 se nessuna corrispondenza. (Questo
implica che gli indici dei caratteri iniziano da uno.)

LUNGHEZZA La lunghezza della stringa abbinata da incontro(); -1 se nessuna corrispondenza.

SOTTOSET Il carattere utilizzato per separare più pedici negli elementi dell'array, di
difetto "\034".

SIMTAB Un array i cui indici sono i nomi di tutte le variabili globali attualmente definite
e array nel programma. L'array può essere utilizzato per l'accesso indiretto alla lettura
oppure scrivi il valore di una variabile:

foo = 5
SYMTAB["pippo"] = 4
stampare foo # stampe 4

I isarray() la funzione può essere utilizzata per verificare se un elemento in SIMTAB offre
Vettore. Non puoi usare il delete dichiarazione con il SIMTAB Vettore.

DOMINIO TESTO Il dominio di testo del programma AWK; usato per trovare le traduzioni localizzate
per le stringhe del programma.

Array
Gli array sono indicizzati con un'espressione tra parentesi quadre ([ ed ]). Se la
espressione è un elenco di espressioni (espr, espr ...) allora il pedice dell'array è una stringa
costituito dalla concatenazione del valore (stringa) di ciascuna espressione, separato dal
valore del SOTTOSET variabile. Questa funzione viene utilizzata per simulare dimensioni multiple
matrici. Per esempio:

i = "UN"; j = "B"; k = "C"
x[io, j, k] = "Ciao, mondo\n"

assegna la stringa "Ciao, mondo\n" all'elemento dell'array x che è indicizzato da
stringa "A\034B\034C". Tutti gli array in AWK sono associativi, cioè indicizzati da valori stringa.

L'operatore speciale in può essere usato per verificare se un array ha un indice costituito da a
particolare valore:

if (val in Vettore)
stampare matrice[valore]

Se l'array ha più pedici, usa (E, j) in schieramento.

I in costrutto può essere utilizzato anche in a per ciclo per iterare su tutti gli elementi di an
Vettore. in ogni caso, il (E, j) in schieramento build funziona solo nei test, non in per loop.

Un elemento può essere cancellato da un array usando il delete dichiarazione. Il delete dichiarazione
può anche essere usato per eliminare l'intero contenuto di un array, semplicemente specificando l'array
nome senza pedice.

guardare con aria sciocca supporta veri array multidimensionali. Non richiede che tali array siano
``rettangolare'' come in C o C++. Per esempio:

a [1] = 5
un[2][1] = 6
un[2][2] = 7

NOTA: Potrebbe essere necessario dirlo guardare con aria sciocca che un elemento dell'array è in realtà un sottoarray da usare
è dove guardare con aria sciocca si aspetta un array (come nel secondo argomento to Diviso()). Tu puoi fare
questo creando un elemento nel sottoarray e poi cancellandolo con il delete
.

Variabile Digitando E altre ancora… Conversione
Le variabili ei campi possono essere numeri (virgola mobile), stringhe o entrambi. Come il valore
di una variabile viene interpretata dipende dal suo contesto. Se usato in un'espressione numerica,
sarà trattato come un numero; se usato come stringa verrà trattato come una stringa.

Per forzare una variabile a essere trattata come un numero, aggiungi 0 ad essa; costringerlo a essere trattato come un
stringa, concatenalo con la stringa nulla.

Le variabili non inizializzate hanno il valore numerico 0 e il valore stringa "" (il null, o
stringa vuota).

Quando una stringa deve essere convertita in un numero, la conversione viene eseguita utilizzando
strtod(3). Un numero viene convertito in una stringa utilizzando il valore di CONVFMT come formato
stringa per sprintf(3), con il valore numerico della variabile come argomento. Però,
anche se tutti i numeri in AWK sono in virgola mobile, i valori integrali sono sempre convertito come
interi. Quindi, dato

CONVFMT = "%2.2f"
a = 12
b = a ""

la variabile b ha un valore di stringa di "12" e non "12.00".

NOTA: Quando si opera in modalità POSIX (come con il --posix opzione), attenzione a quella locale
le impostazioni possono interferire con il modo in cui vengono trattati i numeri decimali: il separatore decimale di
i numeri a cui stai dando da mangiare guardare con aria sciocca deve essere conforme a ciò che si aspetterebbe il tuo locale, sia esso un
virgola (,) o un punto (.).

allocco esegue i confronti come segue: Se due variabili sono numeriche, vengono confrontate
numericamente. Se un valore è numerico e l'altro ha un valore stringa che è un "numerico
string", quindi i confronti vengono eseguiti anche numericamente. Altrimenti, il valore numerico è
convertito in una stringa e viene eseguito un confronto di stringhe. Vengono confrontate due stringhe, of
ovviamente, come stringhe.

Nota che le costanti stringa, come "57", Sono non stringhe numeriche, sono stringhe
costanti. L'idea di "stringa numerica" ​​si applica solo ai campi, getline ingresso, NOME DEL FILE,
ARGV elementi, AMBIENTE elementi e gli elementi di un array creato da Diviso() or
patsplit() che sono stringhe numeriche. L'idea di base è che Utente ingresso, e solo utente
l'input, che sembra numerico, dovrebbe essere trattato in questo modo.

Octal ed Esadecimale Costante
Puoi usare costanti ottali ed esadecimali in stile C nel codice sorgente del tuo programma AWK. Per
esempio, il valore ottale 011 è uguale a decimale 9e il valore esadecimale 0x11 is
uguale al decimale 17.

Corda Costante
Le costanti stringa in AWK sono sequenze di caratteri racchiuse tra virgolette doppie (come
"valore"). All'interno delle stringhe, certo fuga sequenze sono riconosciuti, come in C. Questi sono:

\\ Una lettera rovesciata.

\a Il carattere “avviso”; solitamente il carattere ASCII BEL.

\b Indietro.

\f Avanzamento modulo.

\n Nuova linea.

\r Ritorno a capo.

\t Scheda orizzontale.

\v Scheda verticale.

\xhex cifre
Il carattere rappresentato dalla stringa di cifre esadecimali che segue il \x. I
in ISO C, tutte le cifre esadecimali successive sono considerate parte dell'escape
sequenza. (Questa funzione dovrebbe dirci qualcosa sul design del linguaggio di
comitato.) Ad es. "\x1B" è il carattere ASCII ESC (escape).

\ddd Il carattere rappresentato dalla sequenza di 1, 2 o 3 cifre di cifre ottali. Per esempio,
"\033" è il carattere ASCII ESC (escape).

\c Il carattere letterale c.

Le sequenze di escape possono essere utilizzate anche all'interno di espressioni regolari costanti (ad es.
/[ \t\f\n\r\v]/ corrisponde ai caratteri di spaziatura).

In modalità compatibilità, i caratteri rappresentati da ottale ed esadecimale scappano
le sequenze vengono trattate letteralmente quando vengono utilizzate nelle costanti delle espressioni regolari. Così, /a\52b/
è equivalente /a\*b/.

MODELLI E AZIONI

AWK è un linguaggio orientato alla linea. Prima viene lo schema e poi l'azione. Azione
le dichiarazioni sono racchiuse in { ed }. O potrebbe mancare lo schema, o l'azione potrebbe
mancano, ma ovviamente non entrambi. Se il modello è mancante, l'azione viene eseguita
per ogni singolo record di input. Un'azione mancante equivale a

{ stampare }

che stampa l'intero record.

I commenti iniziano con # carattere e continuare fino alla fine della riga. Righe vuote
possono essere utilizzati per separare le dichiarazioni. Normalmente, un'istruzione termina con una nuova riga, tuttavia,
questo non è il caso delle righe che terminano con una virgola, {, ?, :, &&, o ||. Righe che terminano in do
or altro anche le loro dichiarazioni continuano automaticamente nella riga successiva. In
in altri casi, una riga può essere continuata terminandola con un "\", nel qual caso la nuova riga è
ignorato.

È possibile inserire più istruzioni su una riga separandole con un ";". Questo vale per
entrambe le istruzioni all'interno della parte azione di una coppia modello-azione (il caso normale), e
alle stesse dichiarazioni pattern-action.

Modelli
I modelli AWK possono essere uno dei seguenti:

INIZIO
FINE
INIZIARE
END FILE
/Basic espressione/
relazionale espressione
modello && modello
modello || modello
modello ? modello : modello
(modello)
! modello
pattern1, pattern2

INIZIO ed FINE sono due tipi speciali di pattern che non vengono testati rispetto all'input.
Le parti d'azione di tutti INIZIO i modelli sono uniti come se tutte le affermazioni fossero state
scritto in un unico INIZIO regola. Vengono eseguiti prima della lettura di qualsiasi input.
Allo stesso modo, tutti i FINE le regole vengono unite ed eseguite quando tutto l'input è esaurito (o
quando un exit viene eseguita l'istruzione). INIZIO ed FINE i modelli non possono essere combinati con altri
pattern nelle espressioni pattern. INIZIO ed FINE i modelli non possono avere parti di azione mancanti.

INIZIARE ed END FILE sono ulteriori modelli speciali i cui corpi vengono eseguiti prima
leggendo il primo record di ogni file di input della riga di comando e dopo aver letto l'ultimo record
di ogni file. Dentro il INIZIARE regola, il valore di ERRORE sarà la stringa vuota se
il file è stato aperto con successo. In caso contrario, c'è qualche problema con il file e il
il codice dovrebbe usare file successivo per saltarlo. Se ciò non viene fatto, guardare con aria sciocca produce il suo solito fatale
errore per i file che non possono essere aperti.

Nel /Basic espressione/ pattern, l'istruzione associata viene eseguita per ogni input
record che corrisponde all'espressione regolare. Le espressioni regolari sono le stesse di quelle in
egrep(1), e sono riassunti di seguito.

A relazionale espressione può utilizzare uno qualsiasi degli operatori definiti di seguito nella sezione su
Azioni. Questi generalmente verificano se determinati campi corrispondono a determinate espressioni regolari.

I &&, ||e ! gli operatori sono AND logico, OR logico e NOT logico, rispettivamente,
come in C. Fanno la valutazione del cortocircuito, anche come in C, e servono per combinare di più
espressioni del modello primitivo. Come nella maggior parte delle lingue, le parentesi possono essere usate per cambiare
l'ordine di valutazione.

I ?: operatore è come lo stesso operatore in C. Se il primo modello è vero allora il
il modello utilizzato per il test è il secondo modello, altrimenti è il terzo. solo uno di
vengono valutati il ​​secondo e il terzo pattern.

I pattern1, pattern2 la forma di un'espressione si chiama a gamma modello. Corrisponde a tutto
inserire record che iniziano con un record che corrisponde pattern1, e continuando fino a un record
che corrisponde pattern2, compreso. Non si combina con nessun altro tipo di modello
espressione.

Regolare Espressioni
Le espressioni regolari sono del tipo esteso che si trova in egrep. Sono composti da personaggi
come segue:

c Corrisponde al non metacarattere c.

\c Corrisponde al carattere letterale c.

. Corrisponde a qualsiasi carattere Compreso nuova linea.

^ Corrisponde all'inizio di una stringa.

$ Corrisponde alla fine di una stringa.

[abc...] Un elenco di caratteri: corrisponde a uno qualsiasi dei caratteri abc.... Puoi includere a
gamma di caratteri separandoli con un trattino.

[^abc...] Un elenco di caratteri negato: corrisponde a qualsiasi carattere tranne abc....

r1|r2 Alternanza: corrisponde a entrambi r1 or r2.

r1r2 Concatenazione: corrispondenze r1, e poi r2.

r+ Corrisponde a uno o più r'S.

r* Corrisponde a zero o più r'S.

r? Corrisponde a zero o uno r'S.

(r) Raggruppamento: partite r.

r{n}
r{n,}
r{n,m} Uno o due numeri tra parentesi graffe denotano an intervallo espressione. Se c'è
un numero tra parentesi graffe, l'espressione regolare precedente r si ripete n
volte. Se ci sono due numeri separati da una virgola, r si ripete n a m
volte. Se c'è un numero seguito da una virgola, allora r si ripete almeno
n volte.

\y Corrisponde alla stringa vuota all'inizio o alla fine di una parola.

\B Corrisponde alla stringa vuota all'interno di una parola.

\< Corrisponde alla stringa vuota all'inizio di una parola.

\> Corrisponde alla stringa vuota alla fine di una parola.

\s Corrisponde a qualsiasi carattere di spazio bianco.

\S Corrisponde a qualsiasi carattere non di spaziatura.

\w Corrisponde a qualsiasi carattere costitutivo della parola (lettera, cifra o trattino basso).

\W Corrisponde a qualsiasi carattere che non è un elemento costitutivo della parola.

\` Corrisponde alla stringa vuota all'inizio di un buffer (stringa).

\' Corrisponde alla stringa vuota alla fine di un buffer.

Le sequenze di escape che sono valide nelle costanti stringa (vedi Corda Costante) sono anche
valido nelle espressioni regolari.

Carattere classi sono una funzionalità introdotta nello standard POSIX. Una classe di caratteri è a
notazione speciale per descrivere elenchi di caratteri che hanno un attributo specifico, ma
dove i personaggi stessi possono variare da paese a paese e/o da
set di caratteri a set di caratteri. Ad esempio, la nozione di cos'è un alfabetico
carattere differisce negli Stati Uniti e in Francia.

Una classe di caratteri è valida solo in un'espressione regolare interno le parentesi di un carattere
elenco. Le classi di caratteri sono costituite da [:, una parola chiave che indica la classe e :].
le classi di caratteri definite dallo standard POSIX sono:

[:alnum:] Caratteri alfanumerici.

[:alfa:] Caratteri alfabetici.

[:vuoto:] Spazio o caratteri di tabulazione.

[:ctrl:] Personaggi di controllo.

[:cifra:] Caratteri numerici.

[:grafico:] Caratteri stampabili e visibili. (Uno spazio è stampabile, ma non
visibile, mentre an a è Entrambi.)

[:inferiore:] Caratteri alfabetici minuscoli.

[:Stampa:] Caratteri stampabili (caratteri che non sono caratteri di controllo).

[:punta:] Caratteri di punteggiatura (caratteri che non sono lettere, cifre, controllo
caratteri o spazi).

[:spazio:] Caratteri spazio (come spazio, tabulazione e formfeed, solo per citarne alcuni).

[:superiore:] Caratteri alfabetici maiuscoli.

[:xcifra:] Caratteri che sono cifre esadecimali.

Ad esempio, prima dello standard POSIX, per abbinare i caratteri alfanumerici, avresti
dovuto scrivere /[A-Za-z0-9]/. Se il tuo set di caratteri conteneva altri caratteri alfabetici,
questo non li corrisponderebbe, e se il tuo set di caratteri fosse raccolto in modo diverso da ASCII, questo
potrebbe non corrispondere nemmeno ai caratteri alfanumerici ASCII. Con le classi di caratteri POSIX,
tu puoi scrivere /[[:alnum:]]/, e questo corrisponde ai caratteri alfabetici e numerici in
il tuo set di caratteri, non importa quale sia.

Negli elenchi di caratteri possono apparire due ulteriori sequenze speciali. Questi si applicano ai non ASCII
set di caratteri, che possono avere simboli singoli (chiamati fascicolazione elementi) che sono
rappresentato con più di un carattere, così come diversi caratteri che sono
equivalente per fascicolazione, o ordinamento, scopi. (Ad esempio, in francese, una semplice "e" e a
"`" con accento grave sono equivalenti.)

Simboli di fascicolazione
Un simbolo di fascicolazione è un elemento di fascicolazione multi-carattere racchiuso tra [. ed .].
Per esempio, se ch è un elemento di confronto, allora [[.cap.]] è un'espressione regolare
che corrisponde a questo elemento di confronto, mentre [cap] è un'espressione regolare che
partite sia c or h.

Classi di equivalenza
Una classe di equivalenza è un nome specifico della locale per un elenco di caratteri che sono
equivalente. Il nome è racchiuso in [= ed =]. Ad esempio, il nome e può essere
usato per rappresentare tutte le "e", "´" e "`". In questo caso, [[=e=]] è un normale
espressione che corrisponde a qualsiasi di e, e', o e`.

Queste funzionalità sono molto preziose in locali non di lingua inglese. Le funzioni della libreria
che guardare con aria sciocca gli usi per la corrispondenza delle espressioni regolari attualmente riconoscono solo il carattere POSIX
classi; non riconoscono i simboli di confronto o le classi di equivalenza.

I \y, \B, \<, \>, \s, \S, \w, \W, \`e \' gli operatori sono specifici per guardare con aria sciocca; loro sono
estensioni basate su servizi nelle librerie di espressioni regolari GNU.

Le varie opzioni della riga di comando controllano come guardare con aria sciocca interpreta i caratteri in modo regolare
espressioni.

Nessuna opzione
Nel caso predefinito, guardare con aria sciocca fornisce tutti i servizi delle espressioni regolari POSIX
e gli operatori delle espressioni regolari GNU descritti sopra.

--posix
Sono supportate solo le espressioni regolari POSIX, gli operatori GNU non sono speciali.
(Per esempio, \w corrisponde a un letterale w).

--tradizionale
UNIX tradizionale awk le espressioni regolari sono abbinate. Gli operatori GNU non lo sono
speciali e le espressioni di intervallo non sono disponibili. Personaggi descritti da octal
e le sequenze di escape esadecimali sono trattate letteralmente, anche se rappresentano
metacaratteri delle espressioni regolari.

--re-intervallo
Consenti espressioni di intervallo nelle espressioni regolari, anche se --tradizionale è stata
fornito.

Azioni
Le istruzioni di azione sono racchiuse tra parentesi graffe, { ed }. Le dichiarazioni di azione consistono nelle solite
istruzioni di assegnazione, condizionali e cicliche presenti nella maggior parte delle lingue. Gli operatori,
le istruzioni di controllo e le istruzioni di input/output disponibili sono modellate dopo quelle in C.

Operatori
Gli operatori in AWK, in ordine di precedenza decrescente, sono:

(...) Raggruppamento

$ Riferimento campo.

++ -- Incremento e decremento, sia prefisso che postfisso.

^ elevazione a potenza (** può anche essere usato, e ** = per l'operatore di assegnazione).

+ - ! Più unario, meno unario e negazione logica.

* / % Moltiplicazione, divisione e modulo.

+ - Addizione e sottrazione.

spazio Concatenazione di stringhe.

| |& I/O convogliato per getline, stamparee printf.

< > <= >= != ==
Gli operatori relazionali regolari.

~ !~ Corrispondenza espressione regolare, corrispondenza negata. NOTA: Non utilizzare un regolare costante
espressione (/pippo/) sul lato sinistro di a ~ or !~. Usane solo uno sul
lato destro. L'espressione /pippo/ ~ exp ha lo stesso significato di (($0 ~
/pippo/) ~ exp). Questo di solito è non ciò che si desidera.

in Appartenenza all'array.

&& AND logico.

|| OR logico.

?: L'espressione condizionale C. Questo ha la forma espr1 ? espr2 : espr3. Se
espr1 è vero, il valore dell'espressione è espr2, altrimenti è espr3.
Solo uno di espr2 ed espr3 viene valutato.

= += -= *= /= %= ^=
Incarico. Entrambi assegnamento assoluto (var = APPREZZIAMO) e assegnazione dell'operatore
(le altre forme) sono supportate.

Control Report
Le dichiarazioni di controllo sono le seguenti:

if (condizione) dichiarazione [ altro dichiarazione ]
while (condizione) dichiarazione
do dichiarazione while (condizione)
per (espr1; espr2; espr3) dichiarazione
per (var in schieramento) dichiarazione
rompere
continua
delete schieramento[Index]
delete schieramento
exit [ espressione ]
{ dichiarazioni }
interruttore (espressione) {
Custodie APPREZZIAMO|regex : dichiarazione
...
[ di default: dichiarazione ]
}

I / O Report
Le istruzioni di input/output sono le seguenti:

chiudere(filetto [, come]) Chiudi file, pipe o co-processo. L'opzionale come dovrebbe essere solo
utilizzato quando si chiude un'estremità di un tubo a due vie a un coprocesso. Esso
deve essere anche un valore stringa "per" or "a partire dal".

getline Impostato $0 dal record di input successivo; set NF, NR, FNR, RT.

getline <filetto Impostato $0 dal prossimo record di filetto; impostato NF, RT.

getline var Impostato var dal record di input successivo; set NR, FNR, RT.

getline var <filetto Impostato var dal prossimo record di filetto, RT.

command | getline [var]
Correre command convogliando l'uscita in $0 or var, come sopra, e
RT.

command |& getline [var]
Correre command come co-processo convogliando l'output in $0 or var,
come sopra, e RT. I co-processi sono a guardare con aria sciocca estensione. (command può
essere anche una presa. Vedi la sottosezione Special Compila il nomi, sotto.)

GENERAZIONE Interrompere l'elaborazione del record di input corrente. Il prossimo record di input è
la lettura e l'elaborazione ricominciano con il primo pattern nell'AWK
programma. Al raggiungimento della fine dei dati di input, guardare con aria sciocca esegue qualsiasi
FINE regole).

file successivo Interrompe l'elaborazione del file di input corrente. Il successivo record di input letto
proviene dal file di input successivo. NOME DEL FILE ed ARGINDO sono aggiornati,
FNR viene reimpostato a 1 e l'elaborazione ricomincia con il primo motivo
nel programma AWK. Al raggiungimento della fine dei dati di input, guardare con aria sciocca
esegue qualsiasi FINE regole).

stampare Stampa il record corrente. Il record di output viene terminato con il
valore di TORI.

stampare expr-lista Espressioni di stampa. Ogni espressione è separata dal valore di
UST. Il record di uscita viene terminato con il valore di TORI.

stampare expr-lista >filetto Stampa espressioni su filetto. Ogni espressione è separata dal
valore di UST. Il record di uscita viene terminato con il valore di
TORI.

printf cmq, expr-lista Formatta e stampa. Vedere I printf dichiarazione, Sotto.

printf cmq, expr-lista >filetto
Formatta e stampa su filetto.

sistema(riga cmd) Esegui il comando riga cmde restituire lo stato di uscita. (Questo potrebbe
non essere disponibile su sistemi non POSIX.)

scarico([filetto]) Elimina tutti i buffer associati al file di output aperto o alla pipe filetto.
If filetto manca o se è la stringa nulla, svuota tutto aperto
file di output e pipe.

Sono consentiti reindirizzamenti di output aggiuntivi per stampare ed printf.

stampare ... >> filetto
Aggiunge l'output a filetto.

stampare ... | command
Scrive su una pipa.

stampare ... |& command
Invia i dati a un coprocesso o socket. (Vedi anche la sottosezione Special Compila il nomi,
sotto.)

I getline il comando restituisce 1 in caso di successo, 0 alla fine del file e -1 in caso di errore. su un
errore, ERRORE è impostato su una stringa che descrive il problema.

NOTA: La mancata apertura di una presa a due vie provoca la restituzione di un errore non fatale a
la funzione chiamante. Se si utilizza un tubo, un coprocesso o una presa per getline, O da stampare or
printf all'interno di un ciclo, tu devono obbligatoriamente: uso vicino() per creare nuove istanze del comando oppure
presa. AWK non chiude automaticamente tubi, prese o coprocessi al loro ritorno
EOF.

I printf dichiarazione
Le versioni AWK di printf dichiarazione e sprintf () funzione (vedi sotto) accettare il
seguenti formati di specifica di conversione:

%c Un singolo personaggio. Se l'argomento usato per %c è numerico, viene trattato come a
carattere e stampato. In caso contrario, si presume che l'argomento sia una stringa e il
viene stampato solo il primo carattere di quella stringa.

%d, %i Un numero decimale (la parte intera).

%e, %E Un numero in virgola mobile nella forma [-]d.dddddde[+-]dd. %E il formato usa E
invece di e.

%f, %F Un numero in virgola mobile nella forma [-]ddd.dddddd. Se la libreria di sistema supporta
esso, %F è anche disponibile. Questo è come %f, ma usa lettere maiuscole per speciali
valori "non un numero" e "infinito". Se %F Non è disponibile, guardare con aria sciocca usa %f.

%g, %G Usa il %e or %f conversione, qualunque sia la più breve, con zeri non significativi
soppresso. Il %G il formato usa %E invece di %e.

%o Un numero ottale senza segno (anche un intero).

%u Un numero decimale senza segno (di nuovo, un intero).

%s Una stringa di caratteri.

%x, %X Un numero esadecimale senza segno (un numero intero). Il %X il formato usa ABCDEF invece di
abcdef.

%% Un singolo % carattere; nessun argomento viene convertito.

Parametri aggiuntivi facoltativi possono trovarsi tra i % e la lettera di controllo:

contare$ Usa il contare'esimo argomento a questo punto della formattazione. Questo si chiama a
posizionale specificatore ed è destinato principalmente all'uso nelle versioni tradotte di
stringhe di formato, non nel testo originale di un programma AWK. È un guardare con aria sciocca
estensione.

- L'espressione dovrebbe essere giustificata a sinistra all'interno del suo campo.

spazio Per le conversioni numeriche, premettere i valori positivi con uno spazio e i valori negativi
con un segno meno.

+ Il segno più, usato prima del modificatore di larghezza (vedi sotto), dice di fornire sempre a
segno per le conversioni numeriche, anche se i dati da formattare sono positivi. Il +
sovrascrive il modificatore di spazio.

# Utilizzare un "modulo alternativo" per determinate lettere di controllo. Per %o, fornire un leader
zero. Per %xe %X, fornire un leader 0x or 0X per un risultato diverso da zero. Per %e, %E,
%f ed %F, il risultato contiene sempre un punto decimale. Per %ge %G, finale
gli zeri non vengono rimossi dal risultato.

0 Un leader 0 (zero) funge da flag, che indica che l'output deve essere riempito con
zeri al posto degli spazi. Questo vale solo per i formati di output numerici. Questo
flag ha effetto solo quando la larghezza del campo è maggiore del valore da stampare.

' Un singolo carattere di citazione istruisce guardare con aria sciocca per inserire il separatore delle migliaia delle impostazioni locali
carattere in numeri decimali e per utilizzare anche il punto decimale della locale
carattere con formati in virgola mobile. Ciò richiede il corretto supporto locale nel
libreria C e nella definizione della locale corrente.

larghezza Il campo deve essere riempito con questa larghezza. Il campo è normalmente riempito con
spazi. Con il 0 flag, è riempito con zeri.

.preciso Un numero che specifica la precisione da utilizzare durante la stampa. Per il %e, %E, %f ed
%F, formati, questo specifica il numero di cifre che si desidera stampare a destra di
il punto decimale. Per il %ge %G formati, specifica il numero massimo di
cifre significative. Per il %d, %i, %o, %u, %xe %X formati, specifica il
numero minimo di cifre da stampare. Per %s, specifica il numero massimo di
caratteri dalla stringa che deve essere stampata.

La dinamica larghezza ed preciso capacità dell'ISO C printf () le routine sono supportate. UN *
al posto di entrambi larghezza or preciso specifiche fa sì che i loro valori siano presi da
l'elenco degli argomenti per printf or sprintf (). Per utilizzare uno specificatore di posizione con una dinamica
larghezza o precisione, fornire il contare$ dopo l' * nella stringa di formato. Per esempio,
"%3$*2$.*1$s".

Special Compila il nomi
Quando si esegue il reindirizzamento I/O da entrambi stampare or printf in un file, o tramite getline da parte di un
file, guardare con aria sciocca riconosce internamente alcuni nomi di file speciali. Questi nomi di file consentono l'accesso
per aprire descrittori di file ereditati da guardare con aria sciocca's genitore (di solito la shell). Queste
i nomi dei file possono essere utilizzati anche sulla riga di comando per denominare i file di dati. I nomi dei file sono:

- L'ingresso standard.

/dev/stdin L'ingresso standard.

/dev/stdout L'uscita standard.

/dev/stderr L'output dell'errore standard.

/dev/fd/n Il file associato al descrittore di file aperto n.

Questi sono particolarmente utili per i messaggi di errore. Per esempio:

stampare "Tu soffiò esso!" > "/dev/stderr"

mentre altrimenti dovresti usare

stampare "Tu soffiò esso!" | "gatto 1>&2"

I seguenti nomi di file speciali possono essere usati con il |& operatore di coprocesso per la creazione
Connessioni di rete TCP/IP:

/inet/tcp/lporto/host/rapporto
/inet4/tcp/lporto/host/rapporto
/inet6/tcp/lporto/host/rapporto
File per una connessione TCP/IP su porta locale lporto all'host remoto host sul telecomando
porto rapporto. Usa una porta di 0 per fare in modo che il sistema scelga una porta. Utilizzo /inet4 forzare
una connessione IPv4 e /inet6 per forzare una connessione IPv6. Pianura /inet utilizza l'
impostazione predefinita del sistema (molto probabilmente IPv4).

/inet/udp/lporto/host/rapporto
/inet4/udp/lporto/host/rapporto
/inet6/udp/lporto/host/rapporto
Simile, ma usa UDP/IP invece di TCP/IP.

Numerico funzioni
AWK ha le seguenti funzioni aritmetiche integrate:

atan2 (y, x) Restituisci l'arcotangente di y / x in radianti.

cos (espr) Restituisci il coseno di espr, che è in radianti.

exp (espr) La funzione esponenziale.

intero(espr) Tronca a intero.

tronco d'albero(espr) La funzione logaritmo naturale.

rand () Restituisci un numero casuale N, compreso tra 0 e 1, tale che 0 ≤ N <1.

peccato(espr) Restituire il seno di espr, che è in radianti.

sqrt(espr) Restituisce la radice quadrata di espr.

randa([espr]) Usa il espr come nuovo seme per il generatore di numeri casuali. se no espr is
fornito, utilizzare l'ora del giorno. Restituisci il seme precedente per il random
generatore di numeri

Corda funzioni
allocco ha le seguenti funzioni di stringa incorporate:

assortire (s [, d [, come]]) Restituisce il numero di elementi nell'array di origine s. Ordina il
contenuti di s utilizzando guardare con aria scioccale normali regole per confrontare i valori, e
sostituire gli indici dei valori ordinati s con sequenziale
interi che iniziano con 1. Se l'array di destinazione opzionale d is
specificato, primo duplicato s ai miglioramenti d, e poi ordina d, lasciando il
indici dell'array sorgente s invariato. La stringa opzionale come
controlla la direzione e la modalità di confronto. Valori validi per
come sono una qualsiasi delle stringhe valide per PROCINFO["ordinato_in"]. Questo
può anche essere il nome di una funzione di confronto definita dall'utente come
descritto in PROCINFO["ordinato_in"].

assortiti(s [, d [, come]])
Restituisce il numero di elementi nell'array di origine s. Il comportamento
è uguale a quello di assortire(), tranne che l'array indici sono
utilizzato per l'ordinamento, non i valori dell'array. Al termine, l'array è
indicizzati numericamente, e i valori sono quelli dell'originale
indici. I valori originali vengono persi; quindi fornire un secondo
array se si desidera preservare l'originale. Lo scopo del
stringa opzionale come è lo stesso descritto in assortire() sopra.

gensub(r, s, h [, t]) Cerca la stringa di destinazione t per le corrispondenze dell'espressione regolare
r. Se h è una stringa che inizia con g or G, quindi sostituisci tutto
partite di r con s. Altrimenti, h è un numero che indica quale
partita di r Rimpiazzare. Se t non viene fornito, utilizzare $0 anziché.
All'interno del testo sostitutivo s, la sequenza \n, Dove n è una cifra
da 1 a 9, può essere utilizzato per indicare solo il testo che corrisponde
, il n'esima sottoespressione tra parentesi. La sequenza \0 rappresenta
l'intero testo abbinato, così come il carattere &. a differenza di sub()
ed gsub(), la stringa modificata viene restituita come risultato del
funzione e la stringa di destinazione originale è non cambiato.

gsub(r, s [, t]) Per ogni sottostringa che corrisponde all'espressione regolare r nella stringa
t, sostituisci la stringa se restituire il numero di
sostituzioni. Se t non viene fornito, utilizzare $0È stato anche creato un & nel
il testo sostitutivo viene sostituito con il testo che era effettivamente
abbinato. Uso \& per ottenere un letterale &. (Questo deve essere digitato come
"\\&"; vedere GAWK: Efficace AWK Programmazione per una discussione più completa
delle regole per &e barre rovesciate nel testo sostitutivo di
sub(), gsub()e gensub().)

indice(s, t) Restituisce l'indice della stringa t nella stringa s, o 0 se t non è
regalo. (Ciò implica che gli indici dei caratteri iniziano da uno.)
è un errore fatale usare una costante regexp per t.

lunghezza([s]) Restituisce la lunghezza della stringa s, o la lunghezza di $0 if s non è
fornito. Come estensione non standard, con un argomento array,
lunghezza() restituisce il numero di elementi nell'array.

incontro(s, r [, a]) Riporta la posizione in s dove l'espressione regolare r si verifica, o
0 se r non è presente e impostare i valori di RIAVVIA ed LUNGHEZZA.
Nota che l'ordine degli argomenti è lo stesso di ~ operatore:
str ~ re. Se array a è fornito, a viene cancellato e quindi elementi
1 attraverso n sono riempiti con le porzioni di s che corrispondono a
corrispondente sottoespressione tra parentesi in r. Lo 0° elemento
of a contiene la porzione di s abbinato da tutto il regolare
espressione r. Pedici a[n, "inizio"]e a[n, "lunghezza"]
fornire l'indice iniziale rispettivamente nella stringa e nella lunghezza,
di ogni sottostringa corrispondente.

patsplit(s, a [, r [, settembre]])
Dividi la corda s nell'array a e la matrice dei separatori settembre
sull'espressione regolare re restituire il numero di campi.
I valori degli elementi sono le porzioni di s che corrispondeva r. Il valore di
settembre[i] è il separatore che è apparso davanti a a[i+ 1]. Se r
è omesso, FPAT viene invece utilizzato. gli array a ed settembre sono
cancellato prima. La divisione si comporta in modo identico alla divisione del campo
con FPAT, descritto sopra.

diviso(s, a [, r [, settembre]])
Dividi la corda s nell'array a e la matrice dei separatori settembre
sull'espressione regolare re restituire il numero di campi. Se
r è omesso, FS viene invece utilizzato. gli array a ed settembre sono
cancellato prima. settembre[i] il separatore di campo corrisponde a r
fra a[i] ed a[i+ 1]. Se r è un singolo spazio, quindi principale
spazi bianchi in s va nell'elemento aggiuntivo dell'array settembre[0] ed
lo spazio bianco finale va nell'elemento aggiuntivo dell'array settembre[n],
where n è il valore restituito di diviso(s, a, r, settembre). scissione
si comporta in modo identico alla suddivisione del campo, descritta sopra.

sprintf (FMT, expr-lista) Stampa expr-lista secondo FMTe restituisce la stringa risultante.

stronum(str) Esaminare stre restituisce il suo valore numerico. Se str inizia con a
principale 0, trattalo come un numero ottale. Se str inizia con a
principale 0x or 0X, trattalo come un numero esadecimale. Altrimenti,
supponiamo che sia un numero decimale.

sub(r, s [, t]) Proprio come gsub(), ma sostituisci solo la prima sottostringa corrispondente.

substr(s, i [, n]) Restituisci al massimo n-sottostringa di caratteri di s INIZIO i. Se n
è omesso, usa il resto di s.

ridurre(str) Restituisce una copia della stringa str, con tutti i caratteri maiuscoli
in str tradotti nelle corrispondenti controparti minuscole.
I caratteri non alfabetici vengono lasciati invariati.

tomaia(str) Restituisce una copia della stringa str, con tutti i caratteri minuscoli
in str tradotti nelle corrispondenti controparti maiuscole.
I caratteri non alfabetici vengono lasciati invariati.

allocco è multibyte a conoscenza. Ciò significa che indice(), lunghezza(), sottostr() ed incontro() tutto funziona
in termini di caratteri, non di byte.

Ora funzioni
Poiché uno degli usi principali dei programmi AWK è l'elaborazione di file di registro che contengono tempo
informazioni sul timbro, guardare con aria sciocca fornisce le seguenti funzioni per ottenere timestamp e
formattandoli.

mktime(datepec)
Girare datepec in una marca temporale della stessa forma di quella restituita da tempo di sistema()e
restituire il risultato. Il datepec è una stringa della forma AAAA MM DD HH MM SS[
ora legale]. I contenuti della stringa sono sei o sette numeri che rappresentano
rispettivamente l'intero anno compreso il secolo, il mese dall'1 al 12, il giorno del
il mese da 1 a 31, l'ora del giorno da 0 a 23, i minuti da 0 a
59, il secondo da 0 a 60 e un flag opzionale per l'ora legale. I valori
di questi numeri non è necessario che rientrino negli intervalli specificati; per esempio, un'ora
di -1 significa 1 ora prima della mezzanotte. Il calendario gregoriano di origine zero è
ipotizzato, con l'anno 0 che precede l'anno 1 e l'anno -1 che precede l'anno 0. Il tempo è
si presume che sia nel fuso orario locale. Se il flag dell'ora legale è positivo,
si presume che l'ora sia l'ora legale; se zero, si assume che il tempo sia
essere l'ora standard; e se negativo (il valore predefinito), mktime() tentativi di determinare
se l'ora legale è in vigore per l'ora specificata. Se datepec
non contiene elementi sufficienti o se il tempo risultante è fuori intervallo,
mktime() restituisce -1.

strftime([formato [, timestamp[, bandiera-utc]]])
Formato timestamp secondo la specifica in formato. Se bandiera-utc is
presente ed è diverso da zero o non nullo, il risultato è in UTC, altrimenti il ​​risultato
è nell'ora locale. Il timestamp dovrebbe essere della stessa forma di quello restituito da
tempo di sistema(). Se timestamp mancante, viene utilizzata l'ora corrente. Se formato
manca, un formato predefinito equivalente all'output di quando(1) viene utilizzato. Il
il formato predefinito è disponibile in PROCINFO["strftime"]. Vedere le specifiche per
, il strftime() funzione in ISO C per le conversioni di formato che sono garantite
essere disponibile.

tempo di sistema() Restituisce l'ora del giorno corrente come numero di secondi dall'Epoca
(1970-01-01 00:00:00 UTC sui sistemi POSIX).

Po Manipolazioni funzioni
allocco fornisce le seguenti funzioni di manipolazione dei bit. Funzionano convertendo double-
valori in virgola mobile di precisione a uintmax_t interi, facendo l'operazione, e poi
riconvertendo il risultato in virgola mobile. Le funzioni sono:

e(v1, v2 [,...]) Restituisce l'AND bit per bit dei valori forniti nell'elenco degli argomenti.
Devono essere almeno due.

compl(val) Restituisce il complemento bit a bit di val.

lshift(val, contare) Restituisce il valore di val, spostato a sinistra di contare bit.

o(v1, v2 [,...]) Restituisce l'OR bit per bit dei valori forniti nell'elenco degli argomenti.
Devono essere almeno due.

spostamento(val, contare) Restituisce il valore di val, spostato a destra di contare bit.

xo(v1, v2 [,...]) Restituisce lo XOR bit per bit dei valori forniti nell'elenco degli argomenti.
Devono essere almeno due.

Tipologia Funzione
La seguente funzione è da utilizzare con array multidimensionali.

èarray(x)
Restituisce vero se x è un array, false altrimenti.

Internazionalizzazione funzioni
Le seguenti funzioni possono essere usate dal tuo programma AWK per tradurre le stringhe
in fase di esecuzione. Per tutti i dettagli, vedere GAWK: Efficace AWK Programmazione.

bindtextdominio(elenco [, dominio])
Specificare la directory in cui guardare con aria sciocca cerca il .ogm file, nel caso in cui non lo faranno o
non può essere posizionato nelle posizioni ``standard'' (ad es. durante i test). ritorna
la directory dove dominio è ``vincolato.''
Il predefinito dominio è il valore di DOMINIO TESTO. Se elenco è la stringa nulla
(""), poi bindtextdominio() restituisce l'associazione corrente per il dato dominio.

dcgettext(stringa [, dominio [, categoria]])
Restituisci la traduzione di stringa nel dominio del testo dominio per la categoria locale
categoria. Il valore predefinito per dominio è il valore attuale di DOMINIO TESTO.
valore predefinito per categoria is "LC_MESSAGES".
Se fornisci un valore per categoria, deve essere una stringa uguale a una delle note
categorie locali descritte in GAWK: Efficace AWK Programmazione. Devi anche
fornire un dominio di testo. Uso DOMINIO TESTO se vuoi usare il dominio corrente.

dcngettext(string1, string2, numero [, dominio [, categoria]])
Restituisci la forma plurale usata per numero della traduzione di string1 ed string2 in
dominio del testo dominio per la categoria locale categoria. Il valore predefinito per dominio is
il valore attuale di DOMINIO TESTO. Il valore predefinito per categoria is "LC_MESSAGES".
Se fornisci un valore per categoria, deve essere una stringa uguale a una delle note
categorie locali descritte in GAWK: Efficace AWK Programmazione. Devi anche
fornire un dominio di testo. Uso DOMINIO TESTO se vuoi usare il dominio corrente.

DEFINITO DALL'UTENTE FUNZIONI

Le funzioni in AWK sono definite come segue:

function Nome(parametro stratagemma) { dichiarazioni }

Le funzioni vengono eseguite quando vengono chiamate dall'interno di espressioni in entrambi i modelli o
Azioni. I parametri effettivi forniti nella chiamata di funzione vengono utilizzati per istanziare il
parametri formali dichiarati nella funzione. Gli array vengono passati per riferimento, altro
le variabili vengono passate per valore.

Poiché le funzioni non facevano originariamente parte della lingua AWK, la disposizione per local
variabili è piuttosto goffo: sono dichiarati come parametri extra nell'elenco dei parametri.
La convenzione è di separare le variabili locali dai parametri reali con spazi aggiuntivi nel
lista parametri. Per esempio:

function f(p, q, a, b) # a ed b sono locale
{
...
}

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

La parentesi sinistra in una chiamata di funzione è necessaria per seguire immediatamente la funzione
nome, senza alcuno spazio bianco intermedio. Ciò evita un'ambiguità sintattica con il
operatore di concatenazione. Questa restrizione non si applica alle funzioni integrate elencate
sopra.

Le funzioni possono chiamarsi a vicenda e possono essere ricorsive. Parametri di funzione usati come locali
le variabili vengono inizializzate alla stringa nulla e al numero zero al momento del richiamo della funzione.

Usa il ritorno espr per restituire un valore da una funzione. Il valore restituito non è definito se no
viene fornito il valore, o se la funzione restituisce "cadendo" alla fine.

Come un guardare con aria sciocca estensione, le funzioni possono essere chiamate indirettamente. Per fare ciò, assegna il nome di
la funzione da chiamare, come stringa, a una variabile. Quindi usa la variabile come se fosse
erano il nome di una funzione, preceduto da an @ firma, in questo modo:
function la mia funzione()
{
stampare "la mia funzione chiamato"
...
}

{ ...
la_funzione = "miofun"
@la_funzione() # chiamata attraverso la_funzione a la mia funzione
...
}
A partire dalla versione 4.1.2, funziona con funzioni definite dall'utente, funzioni integrate e
funzioni di estensione.

If --pelucchi è stato fornito, guardare con aria sciocca avverte delle chiamate a funzioni non definite in fase di analisi,
invece che in fase di esecuzione. La chiamata a una funzione non definita in fase di esecuzione è un errore irreversibile.

La parola func può essere usato al posto di function, sebbene questo sia deprecato.

DINAMICAMENTE CARICAMENTO IN CORSO NUOVA FUNZIONI

Puoi aggiungere dinamicamente nuove funzioni integrate alla corsa guardare con aria sciocca interprete con il
@carico dichiarazione. I dettagli completi esulano dallo scopo di questa pagina di manuale; vedere GAWK:
Efficace AWK Programmazione.

SEGNALI

I guardare con aria sciocca profiler accetta due segnali. SIGUSR1 fa sì che scarichi un profilo e una funzione
stack di chiamate al file del profilo, che è o awkprof.out, o qualunque sia il nome del file
con la --profilo opzione. Quindi continua a funzionare. SIGILLO cause guardare con aria sciocca scaricare il
profilo e stack di chiamate di funzione e quindi uscire.

INTERNAZIONALIZZAZIONE

Le costanti stringa sono sequenze di caratteri racchiuse tra virgolette. In non inglese
ambienti parlanti, è possibile contrassegnare le stringhe nel programma AWK come richiedenti
traduzione nella lingua naturale locale. Tali stringhe sono contrassegnate nel programma AWK con
un trattino basso ("_"). Per esempio,

guardare con aria sciocca 'INIZIO { stampare "Ciao, mondo" }'

stampa sempre Ciao, mondo. Ma,

guardare con aria sciocca 'INIZIO { stampare _"Ciao, mondo" }'

potrebbe stampare Buongiorno, monde in Francia.

Ci sono diversi passaggi coinvolti nella produzione e nell'esecuzione di un programma AWK localizzabile.

1. Aggiungi a INIZIO azione per assegnare un valore al DOMINIO TESTO variabile per impostare il dominio del testo
a un nome associato al tuo programma:

INIZIO { DOMINIO TESTO = "mioprog" }

Questo permette guardare con aria sciocca per trovare l' .ogm file associato al tuo programma. Senza questo
passo, guardare con aria sciocca utilizza l' messaggi dominio di testo, che probabilmente non contiene traduzioni
per il tuo programma.

2. Contrassegnare tutte le stringhe da tradurre con caratteri di sottolineatura iniziali.

3. Se necessario, utilizzare il dcgettext() e / o bindtextdominio() funzioni nel tuo programma,
come appropriato.

4. Esegui guardare con aria sciocca --gen-pot -f mioprog.awk > mioprog.pot generare un .pentola file per il tuo
.

5. Fornire traduzioni appropriate e creare e installare il corrispondente .ogm File.

Le caratteristiche di internazionalizzazione sono descritte in dettaglio in GAWK: Efficace AWK
Programmazione.

POSIX COMPATIBILITA '

Un obiettivo primario per guardare con aria sciocca è compatibilità con lo standard POSIX, così come con il
ultima versione di Brian Kernighan's awk. A questa fine, guardare con aria sciocca incorpora quanto segue
caratteristiche visibili all'utente che non sono descritte nel libro AWK, ma fanno parte del Brian
La versione di Kernighan di awke sono nello standard POSIX.

Il libro indica che l'assegnazione della variabile della riga di comando avviene quando awk sarebbe altrimenti
apri l'argomento come file, che è dopo il INIZIO regola viene eseguita. Tuttavia, in
implementazioni precedenti, quando tale assegnazione appariva prima di qualsiasi nome di file, il
l'incarico avverrebbe prima , il INIZIO regola è stata eseguita. Le applicazioni sono diventate dipendenti da
questa caratteristica." quando awk è stato modificato per corrispondere alla sua documentazione, il -v opzione per
l'assegnazione di variabili prima dell'esecuzione del programma è stata aggiunta per ospitare applicazioni che
dipendeva dal vecchio comportamento. (Questa caratteristica è stata concordata da entrambi i Bell
Laboratori e gli sviluppatori GNU.)

Durante l'elaborazione degli argomenti, guardare con aria sciocca utilizza l'apposita opzione “--” per segnalare la fine di
argomenti. In modalità compatibilità, avvisa, ma per il resto ignora le opzioni non definite.
Durante il normale funzionamento, tali argomenti vengono passati al programma AWK per l'elaborazione.

Il libro AWK non definisce il valore di ritorno di randa(). Lo standard POSIX ce l'ha
restituire il seme che stava usando, per consentire di tenere traccia di sequenze numeriche casuali.
Quindi randa() in guardare con aria sciocca restituisce anche il suo seme attuale.

Altre nuove funzionalità sono: L'uso di più -f opzioni (da MKS awk); il AMBIENTE Vettore;
, il \ae \v sequenze di escape (fatto originariamente in guardare con aria sciocca e alimentato di nuovo nella campana
versione laboratori); il ridurre() ed topper() funzioni integrate (dal Bell
versione laboratori); e le specifiche di conversione ISO C in printf (fatto prima in
la versione Bell Laboratories).

STORICO CARATTERISTICHE

C'è una caratteristica delle implementazioni storiche di AWK che guardare con aria sciocca supporta: è possibile
chiamare il lunghezza() funzione incorporata non solo senza argomenti, ma anche senza
parentesi! Così,

a = lunghezza # Santo Algol 60 Batman!

è uguale a uno dei due

a = lunghezza()
a = lunghezza($0)

L'uso di questa funzione è una pratica scadente e guardare con aria sciocca emette un avviso sul suo utilizzo se --pelucchi is
specificato sulla riga di comando.

GNU ESTENSIONI

allocco ha un numero troppo elevato di estensioni per POSIX awk. Sono descritti in questo
sezione. Tutte le estensioni qui descritte possono essere disabilitate invocando guardare con aria sciocca con la
--tradizionale or --posix opzioni.

Le seguenti caratteristiche di guardare con aria sciocca non sono disponibili in POSIX awk.

· Non viene eseguita alcuna ricerca del percorso per i file denominati tramite il -f opzione. Quindi, il PERCORSO IMPERDIBILE
la variabile d'ambiente non è speciale.

· Non è possibile eseguire l'inclusione di file (guardare con aria sciocca's @includere meccanismo).

· Non è possibile aggiungere dinamicamente nuove funzioni scritte in C (guardare con aria sciocca's @carico
meccanismo).

· Il \x sequenza di fuga. (Disabilitato con --posix.)

· La possibilità di continuare le righe dopo ? ed :. (Disabilitato con --posix.)

· Costanti ottali ed esadecimali nei programmi AWK.

· Il ARGINDO, MODALITÀ BIN, ERRORE, LINT, RT ed DOMINIO TESTO le variabili non sono speciali

· Il IGNORECASO variabile e i suoi effetti collaterali non sono disponibili.

· Il LARGHEZZA DI CAMPO suddivisione dei campi a larghezza variabile e fissa.

· Il FPAT suddivisione delle variabili e dei campi in base ai valori dei campi.

· Il PROCINFO matrice non è disponibile.

· L'impiego di RS come espressione regolare.

· I nomi di file speciali disponibili per il reindirizzamento I/O non vengono riconosciuti.

· Il |& operatore per la creazione di coprocessi.

· Il INIZIARE ed END FILE modelli speciali non sono disponibili.

· La capacità di suddividere i singoli caratteri utilizzando la stringa nulla come valore di FS,
e come terzo argomento a Diviso().

· Un quarto argomento opzionale per Diviso() per ricevere i testi separatori.

· Il secondo argomento opzionale per il vicino() funzione.

· Il terzo argomento opzionale per il incontro() funzione.

· La capacità di utilizzare gli specificatori di posizione con printf ed sprintf ().

· La capacità di passare un array a lunghezza().

· Il e(), assortire(), assortiti(), bindtextdominio(), compl(), dcgettext(), dcngettext(),
gensub(), lshift(), mktime(), o(), patsplit(), rshift(), strftime(), stronum(),
tempo di sistema() ed xor() funzioni.

· Stringhe localizzabili.

Il libro AWK non definisce il valore di ritorno del vicino() funzione. allocco's vicino()
restituisce il valore da fchiudi(3), o pchiudi(3), quando si chiude un file di output o una pipe,
rispettivamente. Restituisce lo stato di uscita del processo quando si chiude una pipe di input. Il
il valore restituito è -1 se il file, la pipe o il co-processo denominato non è stato aperto con a
reindirizzamento.

Quando guardare con aria sciocca viene invocato con il --tradizionale opzione, se il fs argomento al -F opzione è
“t”, quindi FS è impostato sul carattere di tabulazione. Nota che digitando guardare con aria sciocca -F\t ... semplicemente cause
la shell per citare la "t" e non passa "\t" al -F opzione. Dal momento che questo è un
caso speciale piuttosto brutto, non è il comportamento predefinito. Anche questo comportamento no
verificarsi se --posix è stato specificato. Per ottenere davvero un carattere di tabulazione come campo
separatore, è meglio usare le virgolette singole: guardare con aria sciocca -F'\t' ....

AMBIENTE VARIABILI

I PERCORSO IMPERDIBILE la variabile d'ambiente può essere utilizzata per fornire un elenco di directory che guardare con aria sciocca
cerca quando si cercano file denominati tramite il -f, --file, -i ed --includere opzioni. Se
la ricerca iniziale fallisce, il percorso viene cercato di nuovo dopo l'aggiunta .accidenti al nome del file.

I AWKLIBPATH la variabile d'ambiente può essere utilizzata per fornire un elenco di directory che guardare con aria sciocca
cerca quando si cercano file denominati tramite il -l ed --carico opzioni.

I GAWK_READ_TIMEOUT la variabile d'ambiente può essere utilizzata per specificare un timeout in
millisecondi per la lettura dell'input da un terminale, tubo o comunicazione bidirezionale compreso
prese.

Per la connessione a un host remoto tramite socket, GAWK_SOCK_RETRIES controlla il numero di
riprova, e GAWK_MSEC_SLEEP e l'intervallo tra i tentativi. L'intervallo è in
millisecondi. Sui sistemi che non supportano dormi(3), il valore è arrotondato ad an
numero intero di secondi.

If POSIXLY_CORRETTO esiste nell'ambiente, allora guardare con aria sciocca si comporta esattamente come se --posix ha avuto
stato specificato sulla riga di comando. Se --pelucchi è stato specificato, guardare con aria sciocca emette un avvertimento
messaggio in tal senso.

EXIT STATUS

Se l' exit l'istruzione viene utilizzata con un valore, quindi guardare con aria sciocca esce con il valore numerico dato
ad esso.

Altrimenti, se non ci sono stati problemi durante l'esecuzione, guardare con aria sciocca esce con il valore della C
costante EXIT_SUCCESSO. Questo di solito è zero.

Se si verifica un errore, guardare con aria sciocca esce con il valore della costante C EXIT_FAILURE. Questo è
di solito uno.

If guardare con aria sciocca esce a causa di un errore fatale, lo stato di uscita è 2. Sui sistemi non POSIX, questo
il valore può essere mappato a EXIT_FAILURE.

VERSIONE INFORMAZIONI

Questa pagina man documenta guardare con aria sciocca, Versione 4.1.

AUTORI

La versione originale di UNIX awk è stato progettato e realizzato da Alfred Aho, Peter
Weinberger e Brian Kernighan dei Bell Laboratories. Brian Kernighan continua a
mantenerlo e valorizzarlo.

Paul Rubin e Jay Fenlason, della Free Software Foundation, hanno scritto guardare con aria sciocca, per essere compatibile
con la versione originale di awk distribuito nella settima edizione UNIX. John Woods
contribuito con una serie di correzioni di bug. David Trueman, con il contributo di Arnold Robbins,
fatto guardare con aria sciocca compatibile con la nuova versione di UNIX awk. Arnold Robbins è la corrente
manutentore.

See GAWK: Efficace AWK Programmazione per un elenco completo dei contributori a guardare con aria sciocca e il suo tool proprietario
documentazione.

Vedere la README file nella guardare con aria sciocca distribuzione per informazioni aggiornate sui manutentori
e quali porte sono attualmente supportate.

INSETTO RAPPORTI

Se trovi un bug in guardare con aria sciocca, si prega di inviare un'e-mail a [email protected]. Per favore
includi il tuo sistema operativo e la sua revisione, la versione di guardare con aria sciocca (Da guardare con aria sciocca --versione),
quale compilatore C hai usato per compilarlo, e un programma di test e dati che sono piccoli come
possibile riprodurre il problema.

Prima di inviare una segnalazione di bug, eseguire le seguenti operazioni. Innanzitutto, verifica di avere
l'ultima versione di guardare con aria sciocca. Molti bug (di solito lievi) vengono corretti ad ogni rilascio,
e se il tuo non è aggiornato, il problema potrebbe essere già stato risolto. Secondo, per favore vedi
se si imposta la variabile d'ambiente LC_TUTTI a LC_TUTTI=C fa sì che le cose si comportino come te
aspettarsi. In tal caso, si tratta di un problema di localizzazione e potrebbe essere o meno un bug. Infine, per favore
leggi attentamente questa pagina man e il manuale di riferimento per essere sicuro che ciò che pensi sia un
bug è davvero, invece di solo una stranezza nella lingua.

Qualunque cosa tu faccia, falla NON posta una segnalazione di bug in comp.lang.awk. Mentre il guardare con aria sciocca sviluppatori
di tanto in tanto leggi questo newsgroup, postare segnalazioni di bug è un modo inaffidabile per segnalare
bug. Si prega invece di utilizzare gli indirizzi di posta elettronica sopra indicati. Veramente.

Se stai usando un sistema basato su GNU/Linux o BSD, potresti voler inviare una segnalazione di bug a
il venditore della vostra distribuzione. Va bene, ma per favore invia una copia al funzionario
anche l'indirizzo e-mail, poiché non vi è alcuna garanzia che la segnalazione di bug venga inoltrata a
, il guardare con aria sciocca manutentore.

Usa gawk online utilizzando i servizi onworks.net