&Anders.Lund; &Anders.Lund.mail;
Johan
Thelmén

    jth@home.se

Översättare

# Reguljära uttryck

    Detta appendix innehåller en kortfattad, men förhoppningsvis tillräcklig och heltäckande introduktion till de reguljära uttryckens  värld. Det dokumenterar reguljära uttryck på den form som är tillgänglig i &kappname;, som inte är likadana som reguljära uttryck i Perl, och inte heller i till exempel grep.

## Inledning

Reguljära uttryck ger oss en möjlighet att beskriva ett möjligt innehåll i en textsträng på ett sätt som enkelt kan förstås av programvara, så att den kan undersöka om texten matchar, och för mer avancerade tillämpningar, ge möjlighet att spara delar av texten som matchar.

Ett exempel: Säg att du vill leta i en text efter stycken som börjar med något av namnen Henrik eller Pernilla, följt av någon form av verbet säga.

Med en normal sökning, skulle du börja med att leta efter det första namnet, Henrik, kanske följt av s på det här sättet: `Henrik s`, och medan du letar efter träffar måste du bortse från alla de som inte inleder ett stycke, samt de där ordet som börjar med s inte var antingen säger, sade etc. Och därefter måste du förstås repetera allt för nästa namn ...

Med reguljära uttryck, kan den här uppgiften utföras med en enda sökning, och med högre noggrannhet.

För att åstadkomma detta, definierar reguljära uttryck detaljerade regler för att beskriva en generell sträng som ska matcha. Vårt exempel, som vi kan beskriva så här med ord: En rad som börjar antingen med Henrik eller Pernilla (möjligen efter upp till fyra mellanslag eller tabulatortecken), följt av ett mellanslag, följt av s och sedan antingen äger eller ade, skulle kunna uttryckas med följande reguljära uttryck:

`^[ \t]{0,4}(Henrik|Pernilla) s(äger|ade)`

Ovanstående exempel demonstrerar alla fyra huvudkoncepten i moderna reguljära uttryck, nämligen:

- Mönster

- Påståenden

- Kvalificering

- Bakåtreferenser

Hatten (`^`) som inleder uttrycket är ett påstående, som bara är sant om den följande strängen som matchar är först på raden.

Strängarna `[ \t]` och `(Henrik|Pernilla) s(äger|ade)` är mönster. Det första är en teckenklass som antingen matchar ett blanktecken eller ett (horisontellt) tabulatortecken. Det andra mönstret innehåller först ett delmönster som antingen matchar `Henrik` eller `Pernilla`, därefter en del som exakt matchar strängen `s` och slutligen ett delmönster som antingen matchar `äger` eller `ade`.

Strängen `{0,4}` är en kvalificering som säger allt från noll upp till fyra av det föregående.

Eftersom programvara för reguljära uttryck stöder konceptet med bakåtreferenser, så sparas hela den matchande delen av strängen, samt delmönster som finns mellan parenteser. Givet något sätt att komma åt de här referenserna, skulle vi kunna få tag på hela matchningen (när man söker i ett textdokument i en editor med ett reguljärt uttryck, så visas den ofta markerad), eller namnet som hittades, eller den sista delen av verbet.

I sin helhet, så matchar uttrycket vad vi ville att det skulle göra, och bara det.

Följande avsnitt beskriver i detalj hur man skapar och använder mönster, teckenklasser, påståenden, kvalificering och bakåtreferenser. Det sista avsnittet ger några användbara exempel.

## Mönster

Mönster består av vanliga strängar och teckenklasser. Mönster kan innehålla delmönster, vilket är mönster som är inneslutna i parenteser.

### Undanta tecken

I mönster och teckenklasser har vissa tecken en särskilt mening. För att uttryckligen matcha något av de här tecknen, måste de markeras eller undantas för att tala om för programvaran för reguljära uttryck att den ska tolka sådana tecken uttryckligen.

Det här görs genom att lägga till ett bakstreck (`\`) före tecknet.

Programvaran för reguljära uttryck ignorerar tecken som undantas även om de inte har någon särskild betydelse i sammanhanget, så att undanta till exempel ett j (`\j`) är säkert. Om du är tveksam om ett tecken kan ha en särskild betydelse, kan du därför alltid undanta det på ett säkert sätt.

Undantag omfattar förstås också bakstrecket själv, för att uttryckligen matcha ett sådant, skulle du skriva `\\`.

### Teckenklasser och förkortningar

En teckenklass är ett uttryck som matchar ett tecken i en mängd angivna tecken. I reguljära uttryck definieras teckenklasser genom att ange de giltiga tecknen i klassen inom hakparenterser, `[]`, eller genom att använda en av de förkortade klasserna som beskrivs nedan.

Enkla teckenklasser innehåller bara uttryckligen ett eller flera tecken, till exempel `[abc]` (som matchar något av tecknen a, b eller c) eller `[0123456789]` (som matchar alla siffror).

Eftersom bokstäver och siffror har en logisk ordning, kan du förkorta dem genom att ange intervall: `[a-c]` är samma sak som `[abc]` och `[0-9]` är samma sak som `[0123456789]`. Att kombineras dessa sammansättningar, till exempel med `[a-fynot1-38]` är fullständigt riktigt (detta skulle förstås matcha antingen a,b,c,d, e,f,y,n,o,t, 1,2,3 eller 8).

Eftersom stora bokstäver är andra tecken än motsvarande små bokstäver, så måste du alltså skriva `[aAbB]`, för att skapa en teckenklass som matchar både de små och stora bokstäverna a eller b.

Det är förstås möjligt att skapa en negativ klass som matchar allting utom. För att göra detta lägg till en hatt (`^`) först i klassen:

`[^abc]` matchar alla tecken utom a, b eller c.

Förutom uttryckliga tecken, definieras några förkortningar, som gör livet lite enklare:

`\a`

  Det här matchar ASCII-tecknet BEL (0x07).

`\f`

  Det här matchar ASCII-tecknet ny sida (FF, 0x0C).

`\n`

  Det här matchar ASCII-tecknet nyrad (LF, 0x0A, Unix nyrad).

`\r`

  Det här matchar ASCII returtecken (CR, 0x0D).

`\t`

  Det här matchar ASCII-tecknet horisontell tabulator (HT, 0x09).

`\v`

  Det här matchar ASCII-tecknet vertikal tabulator (VT, 0x0B).

`\xhhhh`

  Det här matchar Unicode-tecknet som motsvarar det hexadecimala värdet hhhh (mellan 0x0000 och 0xFFFF). \0ooo (dvs. \noll ooo) matchar ASCII/Latin-1 tecknet som motsvarar det oktala värdet ooo (mellan 0 och 0377).

`.` (punkt)

  Det här matchar vilket tecken som helst (inklusive nyrad).

`\d`

  Det här matchar en siffra. Samma som `[0-9]`.

`\D`

  Det här matchar allt utom en siffra. Samma som `[^0-9]` eller `[^\d]`.

`\s`

  Det här matchar ett blanktecken. Nästan samma sak som `[ \t\n\r]`.

`\S`

  Det här matchar allt utom ett blanktecken. Nästan samma sak som `[^ \t\r\n]`, och samma som `[^\s]`.

`\w`

  Matchar alla ord-tecken - i det här fallet alla bokstäver eller siffror. Observera att understreck (`_`) inte matchas, vilket är fallet för motsvarande reguljära uttryck i Perl. Samma som `[a-zA-Z0-9]`.

`\W`

  Matchar alla tecken som inte ingår i ord - allt utom bokstäver eller siffror. Samma som `[^a-zA-Z0-9]` eller `[^\w]`.

De förkortade klasserna kan användas inne i en annan klass. För att till exempel matcha ett ord-tecken, ett mellanslag eller en punkt, skulle du kunna skriva `[\w \.]`.

POSIX-beskrivningen av klasser `[:<klassnamn>:]` stöds inte för närvarande.

#### Tecken med särskild betydelse inne i teckenklasser

Följande tecken har en särskild betydelse inne i konstruktionen [] för teckenklasser, och måste undantas för att användas uttryckligen i en teckenklass:

`]`

  Avslutar teckenklassen. Måste undantas om det inte är det allra första tecknet i klassen (kan följa en hatt som inte undantas).

`^` (hatt)

  Anger en negativ klass, om det är det första tecknet. Måste undantas för att uttryckligen matcha om det är det första tecknet i klassen.

`-` (minus)

  Anger ett logiskt intervall. Måste alltid undantas inne i en teckenklass.

`\` (bakstreck)

  Undantagstecknet. Måste alltid undantas.

### Alternativ: matchar en av

Om du vill matcha en av ett antal olika mönster, kan du skilja dem åt med `|` (ett vertikalt streck).

För att till exempel antingen hitta John eller Harry kan du använda uttrycket `John|Harry`.

### Delmönster

Delmönster är mönster som innesluts i parenteser, och som har flera användningar i de reguljära uttryckens värld.

#### Ange alternativ

Du kan använda ett delmönster för att gruppera ett antal alternativ i ett större mönster. Alternativen delas av tecknet | (vertikalt streck).

För att till exempel matcha antingen orden int, float eller double, skulle du kunna använda mönstret `int|float|double`. Om du bara vill hitta ordet om det följs av blanktecken och därefter några bokstäver, placera alternativen i ett delmönster: `(int|float|double)\s+\w+`.

#### Spara text som matchar (bakåtreferenser)

Om du vill använda en bakåtreferens, använd ett delmönster för att komma ihåg önskad del av mönstret.

Om du till exempel vill hitta två förekomster av samma ord åtskilda av ett kommatecken och möjligen några blanktecken, skulle du kunna skriva `(\w+),\s*\1`. Delmönstret `\w+` skulle hitta en grupp med ord-tecken, och hela uttrycket skulle matcha om de följdes av ett komma, noll eller flera blanktecken och sedan en likadan grupp med ord-tecken. (Strängen `\1` refererar till det första delmönstret inneslutet i parenteser).

#### Påståenden för sökning framåt

Ett påstående för sökning framåt är ett delmönster, som antingen börjar med `?=` eller `?!`.

För att till exempel uttryckligen matcha strängen Bill men bara om den inte följs av Gates, skulle du kunna använda det här uttrycket: `Bill(?! Gates)`. (Det här skulle hitta Bill Clinton samt Billy the kid, men tyst ignorera de andra träffarna).

Delmönster som används för påståenden sparas inte.

Se också Påståenden.

### Tecken med särskild betydelse inne i mönster

Följande tecken har särskild betydelse inne i mönster, och måste undantas om du uttryckligen vill matcha dem:

`\` (bakstreck)

  Undantagstecknet.

`^` (hatt)

  Anger början på strängen.

`$`

  Anger slutet på strängen.

`()` (vänster och höger parentes)

  Anger delmönster.

`{}` (vänster och höger klammer)

  Anger numerisk kvalificering.

`[]` (vänster och höger hakparentes)

  Anger teckenklasser.

`|` (vertikalt streck)

  Logiskt ELLER. Skiljer alternativ.

`+` (plustecken)

  Kvalificering, en eller flera.

`*` (asterisk)

  Kvalificering, noll eller flera.

`?` (frågetecken)

  Ett extra tecken. Kan tolkas som en kvalificering, noll eller ett.

## Kvalificering

En kvalificering låter ett reguljärt uttryck antingen matcha ett angivet antal eller intervall av ett tecken, en teckenklass eller ett delmönster.

En kvalificering innesluts av klamrar (`{` och `}`) och har den allmänna formen `{[minimalt antal][,[maximalt antal]]}`.

Användningen förklaras bäst med exempel:

`{1}`

  Exakt en förekomst

`{0,1}`

  Noll eller en förekomst

`{,1}`

  Samma sak, med mindre ansträngning ;)

`{5,10}`

  Minst 5 men maximalt 10 förekomster

`{5,}`

  Minst 5 förekomster, inget maximum

Det finns dessutom några förkortningar:

`*` (asterisk)

  liknar `{0,}`, hittar ett godtyckligt antal förekomster.

`+` (plustecken)

  liknar `{1,}`, åtminstone en förekomst.

`?` (frågetecken)

  liknar `{0,1}`, noll eller en förekomst.

### Glupskt beteende

När kvalificeringar utan maximum används, så matchar reguljära uttryck normalt så mycket av söksträngen som möjligt, ett beteende som ofta kallas för glupskt.

Modern programvara för reguljära uttryck tillhandahåller en möjlighet att stänga av det glupska beteendet, även om det är det grafiska gränssnittet som måste ge dig tillgång till den här funktionen. En sökdialogruta som tillhandahåller sökning med reguljära uttryck skulle kunna ha en kryssruta som heter Minimal matchning, och borde också ange att glupskt beteende är det normala.

### Exempel i sammanhang

Här är några exempel på att använda kvalificering.

`^\d{4,5}\s`

  Matchar siffrorna i 1234 gå och 12345 nu, men varken 567 elva eller 223459 någonstans.

`\s+`

  Matchar en eller flera blanktecken

`(bla){1,}`

  Matchar samtliga blablabla och bla i blad eller dubbla

`/?>`

  Matchar /> i <slut/> samt > i <start>.

## Påståenden

Påståenden gör att ett reguljärt uttryck bara matchar under vissa kontrollerade omständigheter.

Ett påstående behöver inte ett tecken för att matcha, utan undersöker istället omgivningen runt en möjlig matchning innan den erkänns. Påståendet ordgräns försöker till exempel inte hitta ett tecken som inte ingår i ett ord intill ett ord-tecken på platsen, utan kontrollerar istället att det inte finns ett ord-tecken. Det här betyder att påståendet matchar där det inte finns något tecken alls, dvs. vid slutet på söksträngen.

Vissa påståenden har verkligen ett mönster som ska matcha, men den delen av strängen som matchar kommer inte att ingå i resultatet för matchningen av hela uttrycket.

Reguljära uttryck som de dokumenteras här stöder följande påståenden:

`^` (hatt: början på strängen)

  Matchar början på söksträngen.

  Uttrycket `^Peter` matchar vid Peter i strängen Peter, hej då! men inte Hej, Peter!.

`$` (slutet på strängen)

  Matchar slutet på söksträngen.

  Uttrycket `du\?$` matchar det sista du i strängen Du gjorde det väl inte, eller var det verkligen du? men ingenstans i Du gjorde det väl inte, eller hur?.

`\b` (ordgräns)

  Matchar om det finns ett ordtecken på ena sidan och något annat än ett ordtecken på andra sidan.

  Det här är användbart för att hitta slutet på ord, till exempel för både början och slutet för att hitta ett helt ord. Uttrycket `\bin\b` matchar ett ensamt in i strängen Han kom in genom ingången, men inte det in som finns i ingången.

`\B` (icke ordgräns)

  Matchar överallt där \b inte gör det.

  Det här betyder att det matchar till exempel inne i ord: Uttrycket `\Bin\B` matchar in i minne men inte i ingång eller Han kom in genom fönstret.

`(?=MÖNSTER)` (Positiv sökning framåt)

  Ett påstående som söker framåt tittar på strängen som följer en möjlig matchning. Den positiva sökningen förhindrar att strängen matchar om inte texten som följer den möjliga matchningen matchar MÖNSTER i påståendet, men texten som matchas av det ingår inte i resultatet.

  Uttrycket `vakt(?=\w)` matchar för vakt in vaktmästare men inte i Han är en vakt!

`(?!MÖNSTER)` (Negativ sökning framåt)

  Den negativa sökningen framåt förhindrar en möjlig matchning från att bekräftas om den följande delen av söksträngen matchar sitt MÖNSTER.

  Uttrycket `const \w+\b(?!\s*&)` matchar vid const char i strängen const char* x medan den inte kan matcha const QString i const QString& y eftersom & matchar mönstret i den negativa sökningen framåt.