mawk - Online in de cloud

PROGRAMMA:

NAAM

mawk - patroonscan- en tekstverwerkingstaal

KORTE INHOUD

gek [-W optie] [-F waarde] [-v var=waarde] [--] 'programmatekst' [bestand ...]
gek [-W optie] [-F waarde] [-v var=waarde] [-f programmabestand] [--] [het dossier ...]

PRODUCTBESCHRIJVING

gek is een tolk voor de programmeertaal AWK. De AWK-taal is handig voor:
manipulatie van gegevensbestanden, het ophalen en verwerken van tekst, en voor prototyping en
experimenteren met algoritmen. gek is een nieuwe awk wat betekent dat het de AWK-taal implementeert
zoals gedefinieerd in Aho, Kernighan en Weinberger, De AWK Programming Taal, Addison Wesley
Publishing, 1988. (Hierna het AWK-boek genoemd.) gek voldoet aan de Posix
1003.2 (concept 11.3) definitie van de AWK-taal die een aantal functies bevat die niet
beschreven in het AWK-boek, en gek biedt een klein aantal extensies.

Een AWK-programma is een reeks van patroon {actie} paren en functiedefinities. Kort
programma's worden ingevoerd op de opdrachtregel, meestal tussen ' ' om shell te vermijden
interpretatie. Langere programma's kunnen worden ingelezen uit een bestand met de -f optie. Gegevens
invoer wordt gelezen uit de lijst met bestanden op de opdrachtregel of uit standaardinvoer wanneer de
lijst is leeg. De invoer wordt opgedeeld in records zoals bepaald door het recordscheidingsteken
variabele, RS. Aanvankelijk, RS = "\n" en records zijn synoniem met regels. Elke record is
vergeleken met elk patroon en als het overeenkomt, de programmatekst voor {actie} is
uitgevoerd.

OPTIES

-F waarde stelt het veldscheidingsteken in, FS, te waarde.

-f filet Programmatekst wordt gelezen van filet in plaats van vanaf de opdrachtregel. Meerdere
-f opties zijn toegestaan.

-v var=waarde rechtverkrijgenden waarde om variabele te programmeren var.

-- geeft het ondubbelzinnige einde van opties aan.

De bovenstaande opties zijn beschikbaar bij elke Posix-compatibele implementatie van AWK, en
implementatiespecifieke opties worden voorafgegaan door: -W. gek biedt zes:

-W versie gek schrijft zijn versie en copyright naar stdout en compileerde limieten naar
stderr en verlaat 0.

-W dump schrijft een assembler-achtige lijst van de interne representatie van de
programma naar stdout en verlaat 0 (bij succesvolle compilatie).

-W interactief stelt ongebufferde schrijfacties in naar stdout en regelgebufferde leesbewerkingen van stdin.
Records van stdin zijn regels ongeacht de waarde van RS.

-W exec filet Programmatekst wordt gelezen van filet en dit is de laatste optie. Nuttig op
systemen die de #! "magische nummer" conventie voor uitvoerbare
scripts.

-W sprintf=num past de grootte van mawk's interne sprintf buffer naar num bytes. Meer dan
zeldzaam gebruik van deze optie geeft aan: gek opnieuw moet worden gecompileerd.

-W posix_space krachten gek om '\n' niet als spatie te beschouwen.

De korte vormen -W[vdiesp] worden herkend en op sommige systemen -We is verplicht om te vermijden
beperking van de lengte van de opdrachtregel.

HET AWK TAAL

1. Programma structuur
Een AWK-programma is een reeks van patroon {actie} paren en gebruikersfunctiedefinities.

Een patroon kan zijn:
BEGINNEN
EINDE
uitdrukking
uitdrukking, uitdrukking

Een, maar niet beide, van patroon {actie} kunnen worden weggelaten. Indien {actie} is weggelaten het is
impliciet { print }. Indien patroon wordt weggelaten, dan wordt het impliciet gematcht. BEGINNEN en
EINDE patronen vereisen een actie.

Verklaringen worden beëindigd door nieuwe regels, puntkomma's of beide. Groepen uitspraken zoals
acties of luslichamen worden geblokkeerd via { ... } zoals in C. De laatste instructie in een blok
heeft geen terminator nodig. Blanco regels hebben geen betekenis; een lege instructie wordt beëindigd
met een puntkomma. Lange uitspraken kunnen worden voortgezet met een backslash, \. Een verklaring kan
worden verbroken zonder een backslash na een komma, accolade links, &&, ||, do, anders, het recht
haakje van an if, en or voor statement, en het rechter haakje van een functie
definitie. Een opmerking begint met # en loopt door tot, maar omvat niet het einde van de regel.

De volgende instructies sturen de programmastroom binnen blokken.

if ( uitdrukken ) verklaring

if ( uitdrukken ) verklaring anders verklaring

en ( uitdrukken ) verklaring

do verklaring en ( uitdrukken )

voor ( opt_expr ; opt_expr ; opt_expr ) verklaring

voor ( var in reeks ) verklaring

voortzetten

breken

2. Data types, Conversie en vergelijking
Er zijn twee basisgegevenstypen, numeriek en tekenreeks. Numerieke constanten kunnen een geheel getal zijn zoals
-2, decimaal zoals 1.08, of in wetenschappelijke notatie zoals -1.1e4 of .28E-3. Alle nummers zijn
intern weergegeven en alle berekeningen worden gedaan in drijvende-kommaberekeningen. Dus voor
de uitdrukking 0.2e2 == 20 is bijvoorbeeld waar en waar wordt weergegeven als 1.0.

Stringconstanten staan ​​tussen dubbele aanhalingstekens.

"Dit is een string met een nieuwe regel aan het einde.\n"

Strings kunnen over een regel worden voortgezet door de nieuwe regel te escapen (\). De volgende ontsnapping:
sequenties worden herkend.

\\ \
\" "
\een waarschuwing, ascii 7
\b backspace, ascii 8
\t tabblad, ascii 9
\n nieuwe regel, ascii 10
\v verticale tab, ascii 11
\f formulierinvoer, ascii 12
\r regelterugloop, ascii 13
\ddd 1, 2 of 3 octale cijfers voor ascii ddd
\xhh 1 of 2 hexadecimale cijfers voor ascii hh

Als u aan een ander teken \c ontsnapt, krijgt u \c, dat wil zeggen, gek negeert de ontsnapping.

Er zijn eigenlijk drie basisgegevenstypen; de derde is aantal en snaar die zowel een heeft
numerieke waarde en een tekenreekswaarde tegelijkertijd. Door de gebruiker gedefinieerde variabelen komen in
bestaan ​​wanneer er voor het eerst naar wordt verwezen en worden geïnitialiseerd als nul, een getal en tekenreekswaarde
die de numerieke waarde 0 en de tekenreekswaarde "" heeft. Niet-triviale gegevens met getallen en tekenreeksen
komen van invoer en worden meestal opgeslagen in velden. (Zie paragraaf 4).

Het type van een uitdrukking wordt bepaald door de context en automatische typeconversie
gebeurt indien nodig. Bijvoorbeeld om de uitspraken te evalueren

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

De waarde die is opgeslagen in variabele y wordt numeriek getypt. Als x niet numeriek is, wordt de waarde gelezen
van x wordt geconverteerd naar numeriek voordat het wordt toegevoegd aan 2 en opgeslagen in y. De opgeslagen waarde
in variabele z wordt string getypt en de waarde van x wordt geconverteerd naar string als
noodzakelijk en aaneengeschakeld met "hallo". (Natuurlijk is de waarde en het type opgeslagen in x
niet gewijzigd door enige conversie.) Een tekenreeksuitdrukking wordt geconverteerd naar numeriek met behulp van zijn
langste numerieke prefix zoals met op(3). Een numerieke uitdrukking wordt geconverteerd naar tekenreeks door
vervangen uitdrukken met sprintf(CONVFMT, uitdrukken), behalve uitdrukken kan worden vertegenwoordigd op de host
machine als een exact geheel getal, dan wordt het geconverteerd naar sprint("%NS", uitdrukken). sprintf() is een
AWK ingebouwd die de functionaliteit dupliceert van sprint(3), en CONVFMT is een ingebouwde
variabele gebruikt voor interne conversie van nummer naar string en geïnitialiseerd naar "%.6g".
Expliciete typeconversies kunnen worden afgedwongen, uitdrukken "" is string en uitdrukken+0 is numeriek.

Evalueren, uitdrukken1 her-operatie uitdrukken2, als beide operanden numeriek zijn of getal en tekenreeks, dan:
de vergelijking is numeriek; als beide operanden een string zijn, is de vergelijking een string; als een
operand is string, de niet-string operand wordt geconverteerd en de vergelijking is string. De
resultaat is numeriek, 1 of 0.

In booleaanse contexten zoals, if ( uitdrukken ) verklaring, een tekenreeksexpressie evalueert waar als
en alleen als het niet de lege string "" is; numerieke waarden als en alleen als niet numeriek
nul.

3. Normaal uitdrukkingen
In de AWK-taal worden records, velden en strings vaak getest op het matchen van a regelmatig
uitdrukking. Reguliere expressies staan ​​tussen schuine strepen, en

uitdrukken ~/r/

is een AWK-expressie die evalueert tot 1 als uitdrukken "wedstrijden" r, wat een subtekenreeks van betekent
uitdrukken zit in de reeks strings gedefinieerd door r. Zonder overeenkomst evalueert de uitdrukking tot 0;
door ~ te vervangen door de "not match"-operator, !~ , wordt de betekenis omgekeerd. Als patroon-actie
paren,

/r​ actie } en $0 ~/r​ actie }

zijn hetzelfde, en voor elk invoerrecord dat overeenkomt r, actie is geëxecuteerd. In feite, /r/
is een AWK-expressie die gelijk is aan ($0 ~/r/) overal behalve wanneer aan de rechterkant
kant van een match-operator of doorgegeven als argument aan een ingebouwde functie die een verwacht
reguliere expressie argument.

AWK gebruikt uitgebreide reguliere expressies zoals met egr(1). De reguliere expressie
metatekens, dwz die met een speciale betekenis in reguliere expressies zijn

^ $. [ ] | ( ) * + ?

Reguliere expressies zijn als volgt opgebouwd uit tekens:

c komt overeen met elk niet-metateken c.

\c komt overeen met een teken gedefinieerd door dezelfde escape-reeksen die worden gebruikt in
tekenreeksconstanten of het letterlijke teken c indien \c is geen ontsnapping
volgorde.

. komt overeen met elk teken (inclusief nieuwe regel).

^ komt overeen met de voorkant van een tekenreeks.

$ komt overeen met de achterkant van een tekenreeks.

[c1c2c3...] komt overeen met elk teken in de klasse c1c2c3... . een interval van
karakters wordt aangeduid met c1-c2 binnen een klasse [...].

[^c1c2c3...] komt overeen met elk teken dat niet in de klasse c1c2c3 zit...

Reguliere expressies zijn als volgt opgebouwd uit andere reguliere expressies:

r1r2 overeenkomsten r1 onmiddellijk gevolgd door r2 (aaneenschakeling).

r1 | r2 overeenkomsten r1 of r2 (afwisseling).

r* wedstrijden r nul of meer keer herhaald.

r+ wedstrijden r een of meerdere keren herhaald.

r? wedstrijden r nul of een keer.

(r) wedstrijden r, het verstrekken van groepering.

De toenemende prioriteit van operators is afwisseling, aaneenschakeling en unair (*, + of
?).

Bijvoorbeeld

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

worden vergeleken met respectievelijk AWK-ID's en AWK-numerieke constanten. Let daar op . moet
worden ontsnapt om te worden herkend als een decimaalteken, en dat metatekens niet speciaal zijn
binnen karakterklassen.

Elke uitdrukking kan aan de rechterkant van de ~ of !~ operatoren worden gebruikt of doorgegeven worden aan a
ingebouwd die een reguliere expressie verwacht. Indien nodig wordt het geconverteerd naar string, en
vervolgens geïnterpreteerd als een reguliere expressie. Bijvoorbeeld,

BEGIN { identifier = "[_a-zA-Z][_a-zA-Z0-9]*" }

$0 ~ "^"-ID

drukt alle regels af die beginnen met een AWK-ID.

gek herkent de lege reguliere expressie, //, die overeenkomt met de lege tekenreeks en dus
wordt geëvenaard door elke tekenreeks aan de voorkant, achterkant en tussen elk teken. Bijvoorbeeld,

echo abc | mawk {gsub(//, "X"); afdrukken }
XaXbXcX

4. Archief en velden
Records worden één voor één ingelezen en opgeslagen in de veld- variabele $0. Het record is
splitsen in velden die zijn opgeslagen in $1, $2, ..., $ NF. De ingebouwde variabele NF speelt zich af
naar het aantal velden, en NR en FNR worden verhoogd met 1. Bovenstaande velden $ NF zijn ingesteld op
"".

Opdracht aan $0 veroorzaakt de velden en NF opnieuw te berekenen. Opdracht aan NF of naar een
veldoorzaken $0 te reconstrueren door het aaneenschakelen van de $i's gescheiden door FSO.
Toewijzing aan een veld met een index groter dan NF, verhoogt NF en oorzaken $0 te
gereconstrueerd.

Gegevensinvoer die in velden is opgeslagen, is een tekenreeks, tenzij het hele veld een numerieke vorm heeft en dan
het type is nummer en string. Bijvoorbeeld,

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

$0 en $2 zijn string en $1 is nummer en string. De eerste vergelijking is numeriek, de
de tweede is string, de derde is string (100 wordt geconverteerd naar "100") en de laatste is string.

5. Uitdrukkingen en exploitanten
De syntaxis van de expressie is vergelijkbaar met C. Primaire expressies zijn numerieke constanten, string
constanten, variabelen, velden, arrays en functieaanroepen. De identifier voor een variabele,
array of functie kan een reeks letters, cijfers en onderstrepingstekens zijn, maar dat is niet het geval
beginnen met een cijfer. Variabelen worden niet gedeclareerd; ze bestaan ​​​​wanneer er voor het eerst naar wordt verwezen en zijn
geïnitialiseerd naar nul.

Nieuwe uitdrukkingen worden samengesteld met de volgende operatoren in volgorde van oplopende:
voorrang.

toewijzing = += -= *= /= %= ^=
voorwaardelijk ? :
logisch or ||
logisch en &&
reeks lidmaatschap in
matching ~!~
relationele < > <= >= == !=
aaneenschakeling (geen expliciete operator)
toevoegen ops ​
mul ops ​
unaire ​
logisch niet !
machtsverheffing ^
inc en december ++ -- (zowel post als pre)
veld- $

Toewijzing, voorwaardelijke en machtsverheffing associëren van rechts naar links; de andere operators
van links naar rechts associëren. Elke uitdrukking kan tussen haakjes worden geplaatst.

6. arrays
Awk biedt eendimensionale arrays. Array-elementen worden uitgedrukt als reeks[uitdrukken]. Nadrukkelijk
wordt intern geconverteerd naar het tekenreekstype, dus A[1] en A["1"] zijn bijvoorbeeld hetzelfde
element en de werkelijke index is "1". Door strings geïndexeerde arrays worden associatief genoemd
reeksen. Aanvankelijk is een array leeg; elementen bestaan ​​wanneer ze voor het eerst worden geopend. Een uitdrukking,
uitdrukken in reeks evalueert tot 1 als reeks[uitdrukken] bestaat, anders naar 0.

Er is een vorm van de voor instructie die over elke index van een array loopt.

voor ( var in reeks ) verklaring

sets var naar elke index van reeks en voert uit verklaring. De bestelling die var transversen
de indices van reeks is niet gedefinieerd.

De verklaring, verwijderen reeks[uitdrukken], oorzaken reeks[uitdrukken] niet bestaan. gek ondersteunt een
uitbreiding, verwijderen reeks, die alle elementen van verwijdert reeks.

Multidimensionale arrays worden gesynthetiseerd met aaneenschakeling met behulp van de ingebouwde variabele
SUBSEP. reeks[uitdrukken1,uitdrukken2] is gelijk aan reeks[uitdrukken1 SUBSEP uitdrukken2]. Testen voor een
multidimensionaal element gebruikt een index tussen haakjes, zoals

als ( (i, j) in A ) print A[i, j]

7. Ingebouwde variabelen
De volgende variabelen zijn ingebouwd en geïnitialiseerd voordat het programma wordt uitgevoerd.

ARGC aantal opdrachtregelargumenten.

ARGV array van opdrachtregelargumenten, 0..ARGC-1.

CONVFMT formaat voor interne conversie van getallen naar string, aanvankelijk = "%.6g".

MILIEU array geïndexeerd door omgevingsvariabelen. Een omgevingsreeks, var=waarde
wordt opgeslagen als MILIEU[var] = waarde.

BESTANDSNAAM naam van het huidige invoerbestand.

FNR huidig ​​record aantal in BESTANDSNAAM.

FS splitst records in velden als een reguliere expressie.

NF aantal velden in het huidige record.

NR huidige recordnummer in de totale invoerstroom.

OFMT formaat voor het afdrukken van nummers; aanvankelijk = "%.6g".

FSO ingevoegd tussen velden bij uitvoer, aanvankelijk = " ".

ORS beëindigt elk record bij uitvoer, aanvankelijk = "\n".

RLENGTE lengte ingesteld door de laatste oproep naar de ingebouwde functie, bij elkaar passen().

RS invoerrecordscheidingsteken, aanvankelijk = "\n".

RSTART index ingesteld door de laatste oproep naar bij elkaar passen().

SUBSEP gebruikt om meerdere array-subscripts te bouwen, aanvankelijk = "\034".

8. Ingebouwd functies
String-functies

gsub(r,s,t) gsub(r, s)
Globale substitutie, elke overeenkomst van reguliere expressie r in variabele t is
vervangen door string s. Het aantal vervangingen wordt geretourneerd. Indien t is
overgeslagen, $0 is gebruikt. Een & in de vervangende string s wordt vervangen door de
overeenkomende subtekenreeks van t. \& en \\ zetten respectievelijk letterlijk & en \ in
de vervangende snaar.

inhoudsopgave(NS)
If t is een substring van s, dan de positie waar t starts wordt geretourneerd, anders
0 wordt geretourneerd. Het eerste karakter van s staat op positie 1.

lengte(s)
Retourneert de lengte van de tekenreeks s.

bij elkaar passen(s, r)
Retourneert de index van de eerste langste overeenkomst van reguliere expressie r in
snaar s. Retourneert 0 als er geen overeenkomst is. Als bijwerking, RSTART is ingesteld op de
winstwaarde. RLENGTE is ingesteld op de lengte van de wedstrijd of -1 als er geen wedstrijd is.
Als de lege tekenreeks overeenkomt, RLENGTE is ingesteld op 0, en 1 wordt geretourneerd als
de wedstrijd is aan de voorkant, en lengte(s)+1 wordt geretourneerd als de wedstrijd is op
de rug.

splitsen (s,A,r) splitsen(s,A)
Draad s wordt door reguliere expressie in velden opgesplitst r en de velden zijn
geladen in array A. Het aantal velden wordt geretourneerd. Zie sectie 11
hieronder voor meer informatie. Indien r wordt weggelaten, FS is gebruikt.

sprintf (formaat,expr-lijst)
Geeft een tekenreeks terug die is opgebouwd uit expr-lijst volgens formaat. Zie het
beschrijving van printf() hieronder.

sub(r,s,t) onder(r, s)
Enkele vervanging, hetzelfde als gsub() behalve maximaal één vervanging.

substr(zonde) substr(si)
Retourneert de subtekenreeks van tekenreeks s, beginnend bij index i, van lengte n. Indien n
wordt weggelaten, het achtervoegsel van s, Vanaf i wordt geretourneerd.

verlagen(s)
Retourneert een kopie van s waarbij alle hoofdletters worden omgezet in kleine letters.

topper(s)
Retourneert een kopie van s waarbij alle kleine letters worden omgezet in hoofdletters.

rekenkundige functies

atan2(y,x) Arctan van y/x tussen -pi en pi.

cos (x) Cosinusfunctie, x in radialen.

exp (x) Exponentiële functie.

int(x) Geeft terug x afgekapt naar nul.

logboek(x) Natuurlijke logaritme.

rand() Retourneert een willekeurig getal tussen nul en één.

zonde(x) Sinusfunctie, x in radialen.

kwark(x) Retourneert vierkantswortel van x.

srand (uitdrukken) zand()
Seeds de generator voor willekeurige getallen, met behulp van de klok als uitdrukken wordt weggelaten, en
geeft de waarde van de vorige seed terug. gek zaden het willekeurige nummer
generator van de klok bij het opstarten, dus bellen is niet echt nodig
srand(). srand(uitdrukken) is handig voor het herhalen van pseudo-willekeurige reeksen.

9. Invoer en uitvoer
Er zijn twee uitvoerverklaringen, print en printf.

print schrijft $0 ORS naar standaarduitvoer.

print uitdrukken1, uitdrukken2, ..., uitdrukkenn
schrijft uitdrukken1 FSO uitdrukken2 FSO ... uitdrukkenn ORS naar standaarduitvoer. Numeriek
expressies worden geconverteerd naar string met OFMT.

printf formaat, expr-lijst
dupliceert de printf C-bibliotheekfunctie die naar standaarduitvoer schrijft. De
volledige specificaties van het ANSI C-formaat worden herkend met conversies %c,
%d, %e, %E, %f, %g, %G, %i, %o, %s, %u, %x, %X en %%, en conversie
kwalificaties h en l.

De lijst met argumenten om af te drukken of af te drukken kan optioneel tussen haakjes worden geplaatst. Afdrukken
formatteert getallen met behulp van OFMT of "%d" voor exacte gehele getallen. "%c" met een numeriek argument
drukt het corresponderende 8-bits karakter af, met een stringargument drukt het de eerste af
karakter van de string. De uitvoer van print en printf kan worden omgeleid naar een bestand of
commando door > . toe te voegen filet, >> filet goud | commando aan het einde van de printopdracht.
Omleiding wordt geopend filet or commando slechts één keer, volgende omleidingen worden toegevoegd aan de reeds
stroom openen. volgens afspraak, gek koppelt de bestandsnaam "/dev/stderr" met stderr die
laat print en printf omgeleid worden naar stderr. gek associeert ook "-" en
"/dev/stdout" met stdin en stdout waarmee deze streams kunnen worden doorgegeven aan functies.

De invoerfunctie: getlijn heeft de volgende variaties.

getlijn
leest in $0, werkt de velden bij, NF, NR en FNR.

getline filet
leest in $0 van filet, werkt de velden bij en NF.

getlijn var
leest het volgende record in var, bijwerken NR en FNR.

getlijn var < filet
leest het volgende record van filet om in var.

commando | getlijn
pijpt een record van commando om in $0 en werkt de velden bij en NF.

commando | getlijn var
pijpt een record van commando om in var.

Getline retourneert 0 aan het einde van het bestand, -1 bij een fout, anders 1.

Commando's aan het einde van buizen worden uitgevoerd door /bin/sh.

De functie dichtbij(uitdrukken) sluit het bestand of de pijp die is gekoppeld aan uitdrukken. Sluiten geeft 0 als
uitdrukken is een open bestand, de exit-status als uitdrukken is een doorgesluisd commando, en anders -1. Dichtbij
wordt gebruikt om een ​​bestand of commando opnieuw te lezen, zorg ervoor dat het andere uiteinde van een uitvoerpijp klaar is
of bewaar bestandsbronnen.

De functie doorspoelen(uitdrukken) spoelt het uitvoerbestand of de pijp die is gekoppeld aan uitdrukken. doorspoelen
geeft 0 terug als uitdrukken is een open uitvoerstroom else -1. Spoelen zonder argument spoelt
stevig. Spoelen met een leeg argument ("") spoelt alle open uitvoer.

De functie system(uitdrukken) toepassingen / Bin / sh uitvoeren uitdrukken en retourneert de exit-status van de
commando uitdrukken. Wijzigingen aangebracht in de MILIEU array worden niet doorgegeven aan opdrachten die worden uitgevoerd met
system of pijpen.

10. Gebruiker gedefinieerd functies
De syntaxis voor een door de gebruiker gedefinieerde functie is:

functie naam( betoogt ) { verklaringen }

De hoofdtekst van de functie kan een return-statement bevatten

terugkeer opt_expr

Een retourverklaring is niet nodig. Functieaanroepen kunnen genest of recursief zijn. Functies
zijn doorgegeven expressies op waarde en arrays op verwijzing. Extra argumenten dienen als lokaal
variabelen en worden geïnitialiseerd om nul. Bijvoorbeeld csplit(s,A) zet elk teken van s
in array A en retourneert de lengte van s.

functie csplit(s, A, n, i)
{
n = lengte(s)
for( i = 1 ; ik <= n ; i++ ) A[i] = substr(s, i, 1)
retour n
}

Het plaatsen van extra ruimte tussen doorgegeven argumenten en lokale variabelen is gebruikelijk.
Er kan naar functies worden verwezen voordat ze worden gedefinieerd, maar de functienaam en de '(' van
de argumenten moeten elkaar raken om verwarring met aaneenschakeling te voorkomen.

11. Splitsen snaren, archief en bestanden
Awk-programma's gebruiken hetzelfde algoritme om strings in arrays te splitsen met split() en records
in velden op FS. gek gebruikt in wezen hetzelfde algoritme om bestanden in records te splitsen
on RS.

splitsen(expr, A, sept) werkt als volgt:

(1) Als september wordt weggelaten, wordt vervangen door FS. september kan een uitdrukking zijn of
reguliere expressie. Als het een uitdrukking is van het niet-tekenreekstype, is het:
omgezet naar string.

(2) Als september = " " (een enkele spatie), dan is van voren afgesneden en
achterkant van uitdrukken en september wordt . gek definieert als de gewone
uitdrukking /[ \t\n]+/. Anders september wordt behandeld als een reguliere expressie,
behalve dat meta-tekens worden genegeerd voor een string met lengte 1, bijv.
split(x, A, "*") en split(x, A, /\*/) zijn hetzelfde.

(3) Als uitdrukken is geen string, het wordt geconverteerd naar string. Indien uitdrukken is dan de lege
string "", split() retourneert 0 en A staat leeg. Anders zijn alle niet-
overlappende, niet-null en langste overeenkomsten van september in uitdrukkenScheid uitdrukken om in
velden die worden geladen in A. De velden worden geplaatst in A[1], A[2], ...,
A[n] en split() geven n terug, het aantal velden dat het aantal is van
wedstrijden plus één. Gegevens geplaatst in A dat er numeriek uitziet, is een getypt nummer en
string.

Het splitsen van records in velden werkt hetzelfde, behalve dat de stukken worden geladen in $1, $2, ...,
$ NF. Indien $0 is leeg, NF is ingesteld op 0 en alles $i tot "".

gek splitst bestanden in records door hetzelfde algoritme, maar met het kleine verschil dat:
RS is echt een terminator in plaats van een scheidingsteken. (ORS is ook echt een terminator).

bijv. als FS = ":+" en $0 = "a::b:" , dan NF = 3 en $1 = "een", $2 = "b" en $3 =
"", maar als "a::b:" de inhoud is van een invoerbestand en RS = ":+", dan zijn er
twee records "a" en "b".

RS = " " is niet speciaal.

If FS = "", dan gek breekt het record in afzonderlijke karakters, en op dezelfde manier,
splitsen (s,A,"") plaatst de individuele karakters van s om in A.

12. Meerdere regels archief
Sinds gek interpreteert RS als reguliere expressie zijn records met meerdere regels eenvoudig. Instelling RS
= "\n\n+", maakt een of meer lege regels afzonderlijke records. Indien FS = " " (de standaardinstelling),
dan enkele nieuwe regels, volgens de regels voor hierboven, worden ruimte en enkele nieuwe regels zijn
veld scheidingstekens.

Als een bestand bijvoorbeeld "ab\nc\n\n" is, RS = "\n\n+" en FS = " ", dan is er
één record "ab\nc" met drie velden "a", "b" en "c". Veranderen FS = "\n", geeft
twee velden "ab" en "c"; veranderen FS = "", geeft één veld identiek aan de
record.

Als u wilt dat regels met spaties of tabs als blanco worden beschouwd, stelt u in RS = "\n([ \t]*\n)+".
Voor compatibiliteit met andere awks, instelling RS = "" heeft hetzelfde effect als lege regels
worden ontdaan van de voor- en achterkant van bestanden en vervolgens worden records bepaald alsof RS =
"\n\n+". Posix vereist dat "\n" altijd records scheidt wanneer RS = "" ongeacht de
waarde van FS. gek ondersteunt deze conventie niet, omdat het definiëren van "\n" als
maakt het overbodig.

Meestal als je verandert RS voor records met meerdere regels, wilt u ook wijzigen
ORS naar "\n\n", zodat de recordafstand behouden blijft bij de uitvoer.

13. Programma uitvoering
Deze sectie beschrijft de volgorde van uitvoering van het programma. Eerst ARGC is ingesteld op het totaal
aantal opdrachtregelargumenten doorgegeven aan de uitvoeringsfase van het programma. ARGV[0] is
stel de naam van de AWK-interpreter in en ARGV[1] ... ARGV[ARGC-1] houdt de resterende
opdrachtregelargumenten exclusief opties en programmabron. bijvoorbeeld met

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

ARGC = 5 met ARGV[0] = "makken", ARGV[1] = "v=1", ARGV[2] = "Een", ARGV[3] = "t=hallo" en
ARGV[4] = "B".

Volgende, elk BEGINNEN blok wordt op volgorde uitgevoerd. Als het programma volledig bestaat uit: BEGINNEN
blokken, dan wordt de uitvoering beëindigd, anders wordt een invoerstroom geopend en gaat de uitvoering door.
If ARGC is gelijk aan 1, de invoerstroom is ingesteld op stdin, anders de opdrachtregelargumenten
ARGV[1] ... ARGV[ARGC-1] worden onderzocht op een bestandsargument.

De opdrachtregelargumenten zijn onderverdeeld in drie sets: bestandsargumenten, toewijzingsargumenten
en lege strings "". Een opdracht heeft de vorm var=snaar. Wanneer een ARGV[ik] wordt onderzocht
als een mogelijk bestandsargument, als het leeg is, wordt het overgeslagen; als het een opdracht is
argument, de opdracht om var vindt plaats en i springt naar het volgende argument; anders ARGV[ik]
wordt geopend voor invoer. Als het niet kan worden geopend, wordt de uitvoering beëindigd met afsluitcode 2. Indien nee
opdrachtregelargument is een bestandsargument, dan komt de invoer van stdin. Getline in a BEGINNEN
actie opent invoer. "-" als bestandsargument geeft stdin aan.

Zodra een invoerstroom is geopend, wordt elk invoerrecord tegen elkaar getest patroon, en als het
wedstrijden, de bijbehorende actie is geëxecuteerd. Een expressiepatroon komt overeen als dat zo is
boolean true (zie het einde van sectie 2). EEN BEGINNEN patroon komt overeen voordat enige invoer heeft
gelezen, en een EINDE patroon komt overeen nadat alle invoer is gelezen. Een bereikpatroon,
uitdrukken1,uitdrukken2, komt overeen met elk record tussen de wedstrijd van uitdrukken1 en de wedstrijd uitdrukken2
inclusief.

Wanneer het einde van het bestand optreedt in de invoerstroom, zijn de resterende opdrachtregelargumenten:
onderzocht op een bestandsargument, en als er een is, wordt het geopend, anders de EINDE patroon is
als overeenkomend beschouwd en zo EINDE acties worden uitgevoerd.

In het voorbeeld vindt de toewijzing v=1 plaats na de BEGINNEN acties worden geëxecuteerd, en
de gegevens die in v zijn geplaatst, zijn een getypt nummer en een tekenreeks. Invoer wordt dan gelezen uit bestand A. Aan het einde
van bestand A, wordt t ingesteld op de tekenreeks "hallo", en B wordt geopend voor invoer. Aan het einde van bestand B,
the EINDE acties worden uitgevoerd.

Programmaverloop bij de patroon {actie} niveau kan worden gewijzigd met de

volgende
afrit opt_expr

verklaringen. EEN volgende statement zorgt ervoor dat het volgende invoerrecord wordt gelezen en patroontesten
om opnieuw te beginnen met de eerste patroon {actie} paar in het programma. Een afrit verklaring veroorzaakt
onmiddellijke uitvoering van de EINDE acties of programmabeëindiging als die er niet zijn of als de
afrit komt voor in een EINDE actie. De opt_expr stelt de exit-waarde van het programma in, tenzij
overschreven door een later afrit of latere fout.

Voorbeelden

1. emuleren kat.

{ afdrukken }

2. emuleren wc.

{ chars += lengte($0) + 1 # voeg een toe voor de \n
woorden += NF
}

EINDE{ print NR, woorden, tekens }

3. tel het aantal unieke "echte woorden".

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

{ voor (i = 1 ; ik <= NF ; i++) woord [$i] = "" }

EINDE { woord verwijderen[""]
voor ( i in woord ) cnt++
print ct
}

4. tel het tweede veld van elk record op op basis van het eerste veld.

$1 ~ /tegoed|winst/ { som += $2 }
$1 ~ /debet|verlies/ { som -= $2 }

EINDE { print som }

5. sorteer een bestand, vergelijk als string

{ line[NR] = $0 "" } # zorg voor het vergelijkingstype
# voor het geval sommige regels numeriek lijken

EINDE { isort(regel, NR)
for(i = 1 ; i <= NR ; i++) print regel[i]
}

#insertion soort van A[1..n]
functie isort( A, n, i, j, vasthouden)
{
voor( ik = 2 ; ik <= n ; i++)
{
houd = A[j = ik]
terwijl ( A[j-1] > vasthouden )
{ J-- ; A[j+1] = A[j] }
A[j] = vasthouden
}
# sentinel A[0] = "" wordt aangemaakt indien nodig
}

COMPATIBILITEIT KWESTIES

De Posix 1003.2 (draft 11.3) definitie van de AWK-taal is AWK zoals beschreven in de AWK
boek met een paar extensies dat verscheen in SystemVR4 nawk. De extensies zijn:

Nieuwe functies: toupper() en tolower().

Nieuwe variabelen: ENVIRON[] en CONVFMT.

ANSI C-conversiespecificaties voor printf() en sprintf().

Nieuwe commando-opties: -v var=value, meerdere -f opties en implementatie-opties
als argumenten voor -W.

Posix AWK is erop gericht om bestanden regel voor regel te bewerken. RS kan worden gewijzigd van "\n"
naar een ander enkel teken, maar het is moeilijk om hier iets voor te vinden - er zijn geen
voorbeelden in het AWK boek. volgens afspraak, RS = "", maakt een of meer lege regels gescheiden
records, waardoor records met meerdere regels mogelijk zijn. Wanneer RS = "", "\n" is altijd een veldscheidingsteken
ongeacht de waarde in FS.

gek, aan de andere kant, laat RS een reguliere expressie zijn. Wanneer "\n" verschijnt in
records, wordt het behandeld als ruimte, en FS bepaalt altijd velden.

Het verwijderen van de regel tegelijk paradigma kan sommige programma's eenvoudiger maken en kan vaak verbeteren
uitvoering. Bijvoorbeeld door voorbeeld 3 van hierboven opnieuw te doen,

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

{ woord [ $0 ] = "" }

EINDE { woord verwijderen [ "" ]
voor (ik in woord) cnt++
print ct
}

telt het aantal unieke woorden door van elk woord een record te maken. Op bestanden van gemiddelde grootte,
gek voert twee keer zo snel uit, vanwege de vereenvoudigde binnenlus.

Het volgende programma vervangt elke opmerking door een enkele spatie in een C-programmabestand,

BEGINNEN {
RS = "/\*([^*]|\*+[^/*])*\*+/"
# commentaar is recordscheidingsteken
ORS = " "
lijn vasthouden
}

{ print hold ; vasthouden = $0 }

EINDE { printf "%s" , vasthouden }

Het bufferen van één record is nodig om te voorkomen dat het laatste record met een spatie wordt afgesloten.

met gek, de volgende zijn allemaal gelijkwaardig,

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

De tekenreeksen worden twee keer gescand, één keer als tekenreeks en één keer als reguliere expressie. Op de
string-scan, gek negeert de ontsnapping op niet-escape-personages terwijl het AWK-boek pleit
\c erkend worden als c waardoor dubbele ontsnapping van meta-tekens in
snaren. Posix weigert expliciet het gedrag te definiëren dat programma's passief dwingt
die onder verschillende awks moet draaien om de meer draagbare maar minder leesbare, dubbele
ontsnappen.

Posix AWK herkent "/dev/std{out,err}" of \x hex escape-reeksen in strings niet.
In tegenstelling tot ANSI C, gek beperkt het aantal cijfers dat volgt op \x tot twee als de huidige
implementatie ondersteunt alleen 8 bit karakters. de ingebouwde doorspoelen verscheen voor het eerst in een
recent (1993) AT&T awk vrijgegeven voor netlib, en maakt geen deel uit van de posix-standaard.
Geaggregeerde verwijdering met verwijderen reeks maakt geen deel uit van de posix-standaard.

Posix verlaat expliciet het gedrag van FS = "" undefined, en vermeldt het splitsen van de
opnemen in karakters als een mogelijke interpretatie, maar momenteel is dit gebruik niet
draagbaar over implementaties heen.

Eindelijk, hier is hoe gek behandelt uitzonderlijke gevallen die niet in het AWK-boek of de
Posix ontwerp. Het is onveilig om consistentie tussen awks aan te nemen en veilig om naar de volgende te gaan
pagina.

substr(s, i, n) retourneert de karakters van s in het snijpunt van de gesloten
interval [1, lengte(s)] en het halfopen interval [i, i+n). Wanneer dit
intersectie is leeg, de lege string wordt geretourneerd; dus substr("ABC", 1, 0) = ""
en substr("ABC", -4, 6) = "A".

Elke string, inclusief de lege string, komt overeen met de lege string aan de voorkant, dus
s ~ // en s ~ "", zijn altijd 1 zoals match(s, //) en match(s, ""). De laatste twee
reeks RLENGTE om 0.

index(s, t) is altijd hetzelfde als match(s, t1) waarbij t1 hetzelfde is als t met
metakarakters ontsnapt. Vandaar dat consistentie met match vereist dat index(en, "")
geeft altijd 1 terug. Ook de voorwaarde, index(s,t) != 0 als en alleen t een subtekenreeks is
van s, vereist index ("","") = 1.

Als getline het einde van het bestand tegenkomt, laat getline var var ongewijzigd. evenzo,
bij binnenkomst in de EINDE acties, $0, de velden en NF hebben hun waarde ongewijzigd van
de laatste opname.

Gebruik mawk online met onworks.net-services