{"canonical_url":"https://engineer.company/nb/glossary/regular-expression/","content_markdown":"# Regulært uttrykk\n\n## Hva det er\n\nEt regulært uttrykk er et kort mønster som beskriver en mengde tekststrenger,\nslik at et program kan plukke ut dem som hører til. POSIX-standarden, som The\nOpen Group og IEEE gir ut, åpner kapitlet sitt om emnet med å beskrive regulære\nuttrykk som en måte å velge ut bestemte strenger fra en mengde tegnstrenger på.\nI dagligtale og i navnene på mange funksjoner og biblioteker krymper begrepet\ntil regex, eller til regexp, som er skrivemåten i JavaScripts RegExp-objekt og i\nregexp-pakken i Go.\n\nDe fleste tegn i et mønster står for seg selv: en `a` i mønsteret matcher en `a`\ni teksten. Noen få er spesielle. Et punktum matcher et hvilket som helst tegn,\n`*` gjentar det som står foran, null eller flere ganger, et uttrykk i\nhakeparenteser som `[0-9]` matcher ett tegn fra en mengde, `^` og `$` binder\nmønsteret til starten og slutten, og et intervall som `{4}` krever et bestemt\nantall gjentakelser. Dermed beskriver `^[0-9]{4}$` enhver streng som består av\nnøyaktig fire sifre, uten andre tegn før eller etter. Standardens eget eksempel\npå et intervall er `c{3}` brukt på `abababccccccd`: det matcher det sjuende til\nniende tegnet, de tre første av de seks c-ene.\n\nDet finnes mer enn én dialekt. POSIX definerer selv to: grunnleggende regulære\nuttrykk (BRE), som de fleste av verktøyene i standarden bruker, og utvidede\nregulære uttrykk (ERE), som noen bruker i stedet. C-funksjonene `regcomp()` og\n`regexec()` tilbyr begge. Forskjellen er ikke kosmetisk. I et ERE betyr `a+` én\neller flere `a`. I et BRE er `+` et vanlig tegn, og standarden overlater til\nhver implementasjon om `\\+` betyr én eller flere eller et bokstavelig plusstegn.\n\nDen andre store familien stammer fra Perl. ECMAScript-spesifikasjonen slår fast\nat formen og funksjonaliteten til regulære uttrykk i JavaScript er modellert\netter funksjonaliteten for regulære uttrykk i Perl 5. Regexp-pakken i Go\nbeskriver syntaksen sin som den generelle syntaksen som Perl, Python og andre\nspråk bruker, og `re`-modulen i Python er et tredje medlem. Disse motorene deler\ndet meste av notasjonen, men ikke hver detalj. Forkortelsesklassene er et godt\neksempel: `\\d` (et siffer) og `\\w` (et ordtegn) ser like ut overalt, men hva de\ndekker, avhenger av motoren og flaggene, som avsnittet om praksis nedenfor\nviser.\n\n## Hvorfor det er viktig\n\nRegulære uttrykk sitter i mye programvare som ikke ser ut som behandling av\ntekst: validering av skjemafelt, filtre som henter verdier ut av logglinjer,\nrutingregler i webservere, søk og erstatt i tekstredigeringsprogrammer. Hvert\nmønster er kort, og derfor er det lett å overse hva det faktisk godtar. To\nspørsmål avgjør resultatet, og svaret på begge avhenger av motoren: hvilket\ntreff som velges når flere er mulige, og hvor lang tid det kan ta å finne ett.\n\nPOSIX velger treffet som står lengst til venstre, og blant dem det lengste: av\nalle treffene som begynner tidligst i teksten, vinner det lengste, på engelsk\nleftmost-longest. Standardens eksempler er BRE-et `bb*`, som matcher andre til\nfjerde tegn i `abbbc`, og ERE-et `(wee|week)(knights|night)`, som matcher alle\nti tegnene i `weeknights`. Perl-familien jobber annerledes. Den prøver\nalternativene i den rekkefølgen de er skrevet, og tar det første som fører til\net treff, det dokumentasjonen til Go kaller leftmost-first. Det samme mønsteret\npå den samme teksten kan derfor gi to svar:\n\n```text\n$ echo ab | grep -oE 'a|ab'\nab\n\u003e\u003e\u003e re.search(\"a|ab\", \"ab\").group()\n'a'\n\u003e \"ab\".match(/a|ab/)[0]\n'a'\n```\n\nGo tilbyr begge deler. Funksjonen `Compile` bruker leftmost-first, mens\n`CompilePOSIX` begrenser syntaksen til POSIX ERE og bytter til leftmost-longest.\nSelv da beholder pakken sin egen regel for hvilke deltreff som velges, og\ndokumentasjonen forklarer hvorfor: POSIX-regelen er ifølge den uoverkommelig dyr\nå beregne og ikke engang veldefinert.\n\nDet andre spørsmålet er tid. `re` i Python backtracker, som de fleste motorer i\nPerl-familien. Når en del av mønsteret ikke kommer videre, går motoren et steg\ntilbake og prøver en annen måte å matche det foregående på. Dokumentasjonen til\nPython viser ideen med `a*a` mot `aaaa`: `a*` tar først alle fire bokstavene og\ngir så én tilbake, slik at den siste `a` kan matche. For de fleste mønstre er\nkostnaden usynlig. For noen vokser antallet måter å prøve på eksponentielt med\nlengden på inndataene, og en streng på noen dusin tegn kan holde en prosessor\nopptatt i minutter. MITRE katalogiserer dette som CWE-1333, Inefficient Regular\nExpression Complexity, og oppgir ReDoS (regular expression denial of service) og\ncatastrophic backtracking som andre navn på det. Regexp-pakken i Go ble utformet\nrundt det motsatte løftet. Dokumentasjonen slår fast at matchingen garantert\nkjører i tid som er lineær i størrelsen på inndataene, og legger til at de\nfleste implementasjoner med åpen kildekode ikke gir noen slik garanti.\n\n## Slik ser det ut i praksis\n\nTa et registreringsskjema for kunder i Danmark og Ukraina, og et fornavnfelt som\nbare skal godta bokstaver. Det opplagte mønsteret er `[A-Za-z]+`, og i Python\n3.15 oppfører det seg slik:\n\n```text\n\u003e\u003e\u003e import re\n\u003e\u003e\u003e re.fullmatch(r\"[A-Za-z]+\", \"Mia\")\n\u003cre.Match object; span=(0, 3), match='Mia'\u003e\n\u003e\u003e\u003e re.fullmatch(r\"[A-Za-z]+\", \"Søren\")\n\u003e\u003e\u003e re.fullmatch(r\"[A-Za-z]+\", \"Олена\")\n\u003e\u003e\u003e re.fullmatch(r\"\\w+\", \"Søren_42\")\n\u003cre.Match object; span=(0, 8), match='Søren_42'\u003e\n\u003e\u003e\u003e re.fullmatch(r\"[^\\W\\d_]+\", \"Олена\")\n\u003cre.Match object; span=(0, 5), match='Олена'\u003e\n\u003e\u003e\u003e re.fullmatch(r\"[^\\W\\d_]+\", \"Søren_42\")\n\u003e\u003e\u003e\n```\n\nEt kall som returnerer `None`, skriver ikke ut en eneste linje i det interaktive\nskallet, så ASCII-klassen avviser Søren og Олена (Olena), to helt vanlige navn i\nKøbenhavn og Kyiv. Bytter man til `\\w`, slipper de gjennom, men i Python dekker\n`\\w` alle tegn som `str.isalnum()` er sann for, pluss understreken, så klassen\nslipper også inn `Søren_42`. Klassen `[^\\W\\d_]` utelukker tegn som ikke er\nordtegn, desimalsifre og understreken. Den slipper også gjennom enkelte talltegn\nsom ikke er desimalsifre, så den er ingen streng test for bare bokstaver. For\nnavn på mer enn ett ord godtar `[^\\W\\d_]+( [^\\W\\d_]+)*` både\n`Anne Sofie Østergaard` og `Олена Коваль`. Mønsteret avviser fortsatt en\n`Anne-Marie` med bindestrek, og det er en grunn til å holde et navnefelt så\nromslig som virksomheten tåler. POSIX-verktøy har det samme problemet i en annen\nform: standarden lar betydningen av et tegnområde som `A-Z` være uspesifisert\nutenfor POSIX-localet og tilbyr klassen `[[:alpha:]]`, der det gjeldende localet\nbestemmer hvilke tegn som hører med.\n\nÅ få dette riktig betyr mer enn ett skjema. En av tjenestene på dette\nnettstedet,\n[Internasjonalisering og lokalisering](/nb/services/i18n-localization/),\nbeskriver målet som programvare som leses naturlig i alle markeder kunden selger\ni, helt ned til måten navn sorteres på. Et navnefelt som avviser Søren, kommer\ntil kort lenge før noen sortering finner sted.\n\nSifre reiser det motsatte spørsmålet. Et dansk postnummer består av fire sifre,\nså `\\d{4}` ser ut som en trygg kontroll av `2200`. I Python matcher `\\d` i et\ntekstmønster likevel ethvert desimalsiffer i Unicode, ikke bare 0 til 9, og\ngodtar det samme postnummeret skrevet med arabisk-indiske sifre:\n\n```text\n\u003e\u003e\u003e s = \"\\u0662\\u0662\\u0660\\u0660\"\n\u003e\u003e\u003e print(s, int(s))\n٢٢٠٠ 2200\n\u003e\u003e\u003e re.fullmatch(r\"\\d{4}\", s)\n\u003cre.Match object; span=(0, 4), match='٢٢٠٠'\u003e\n\u003e\u003e\u003e re.fullmatch(r\"\\d{4}\", s, re.ASCII)\n\u003e\u003e\u003e re.fullmatch(r\"[0-9]{4}\", s)\n\u003e\u003e\u003e\n```\n\nJavaScript står på den andre siden. ECMAScript-spesifikasjonen definerer `\\d`\nsom nøyaktig de ti tegnene 0 til 9, så `/^\\d{4}$/.test(s)` returnerer `false` i\nNode.js for den samme strengen, mens `/^\\p{Nd}{4}$/u` returnerer `true`. Et\nskjema som kontrolleres i nettleseren med den ene regelen og på serveren med den\nandre, vil være uenig med seg selv om de samme inndataene. `int()` i Python\nleser strengen som 2200, men en databasekolonne, en oppslagstabell eller en\nannen tjeneste gjør kanskje ikke det. Bestem hvilke sifre som menes: `[0-9]`\neller flagget `re.ASCII` når bare ASCII-sifre holder, og `\\p{Nd}` med flagget\n`u` i JavaScript når ethvert desimalsiffer er velkomment.\n\n## Hvor det går galt\n\n**Et mønster som dobler tiden for hver bokstav.** Et navnemønster som skal\ntillate ord skilt med enkle mellomrom, skrives lett som `([^\\W\\d_]+ ?)+`. På et\ngyldig navn er det raskt. På en rekke bokstaver fulgt av et tegn det ikke kan\ngodta, prøver motoren alle måter å dele bokstavene inn i ord på før den gir opp,\nog antallet måter dobles for hver bokstav. På én maskin med Python 3.15 ga den\nraskeste av fem kjøringer for hver lengde disse tidene for `fullmatch` på en\nstreng av bokstaver fulgt av `!`:\n\n```text\nletters   seconds\n     18     0.017\n     20     0.067\n     22     0.27\n     24     1.0\n     26     4.1\n```\n\nHver bokstav dobler tiden, så to bokstaver til firedobler den. Regner man videre\nmed den faktoren, ville tretti bokstaver ta omtrent ett minutt og trettito mer\nenn fire minutter. Dette er tilfellet CWE-1333 beskriver: backtracking-forsøkene\nvokser eksponentielt med inndataene, inndataene trenger ikke å matche, og de kan\nvære lange nok. Omskrivingen `[^\\W\\d_]+( [^\\W\\d_]+)*` beskriver de samme navnene\nuten en nøstet kvantifikator, avviser strengen på 24 bokstaver på omtrent ett\nmikrosekund og en million bokstaver fulgt av `!` på omtrent tretti\nmillisekunder. Fjern nøstede kvantifikatorer, begrens lengden på inndataene før\nde matches, og kjør mønstre som ser inndata man ikke kan stole på, på en motor\nmed garantert lineær tid, som den i Go.\n\n**Søk der hele verdien skal matche.** I Python godtar `re.search` et treff hvor\nsom helst i strengen, og `re.match` forankrer bare i starten; Python 3.15 gir\nden det tydeligere navnet `prefixmatch` og merker det gamle navnet som soft\ndeprecated, med en merknad om at andre språk bruker match om det Python alltid\nhar kalt search. Dermed lykkes `re.prefixmatch(r\"\\d{4}\", \"22000\")` på de fire\nførste sifrene, og `re.search(r\"\\d{4}\", \"DK-2200\")` finner postnummeret inne i\nstrengen. Selv `re.search(r\"^\\d{4}$\", \"2200\\n\")` lykkes, fordi `$` også matcher\nrett før et linjeskift på slutten. `re.fullmatch`, som har vært med siden Python\n3.4, avviser alle tre. Bruk `fullmatch` når et mønster beskriver hele verdien,\neller forankre med `\\A` og `\\Z`, som Python 3.14 også staver `\\z`.\n\n**En tillatelsesliste med et løst punktum.** En kontroll som bare slipper\nomdirigeringer til selskapets eget nettsted, kan skrives som\n`^https://www.example.com`. Den godtar `https://www.example.com.evil.example/`,\nfordi mønsteret slutter før vertsnavnet gjør, og hvert punktum uten escape\nmatcher et hvilket som helst tegn, så en vert som skiller seg fra den ekte med\nett enkelt tegn i stedet for et punktum, slipper også gjennom. Å escape\npunktumene, slik `re.escape(\"www.example.com\")` gjør, og avslutte mønsteret med\n`/` lukker begge hullene. Enda bedre: parse URL-en, og sammenlign vertsnavnet\nmed det forventede som en hel streng.\n\n**Et mønster som flyttes mellom motorer.** Et mønster som er testet med\n`grep -E` og limt inn i Python, kan velge et annet treff, slik eksemplet med\n`a|ab` viser, og et som virker i ett BRE-verktøy med `\\+`, kan bety et\nbokstavelig plusstegn i et annet. Den samme `\\d` som godtar arabisk-indiske\nsifre i Python, avviser dem i JavaScript. Test hvert mønster i motoren som skal\nkjøre det, med flaggene det skal kjøre med.\n\n**Et globalt flagg som husker.** I JavaScript lagrer et regulært uttrykk med\nflagget `g` eller `y` posisjonen der det siste treffet sluttet, i `lastIndex`,\nog starter neste søk der; etter et mislykket forsøk nullstiller det `lastIndex`\ntil 0. Et mønster som ligger i en konstant og gjenbrukes til validering, svarer\nda ulikt annenhver gang:\n\n```text\n\u003e const re = /^\\d{4}$/g;\nundefined\n\u003e re.test(\"2200\")\ntrue\n\u003e re.test(\"2200\")\nfalse\n\u003e re.test(\"2200\")\ntrue\n```\n\nUtelat flagget `g` på mønstre som brukes med `test()`, eller sett `lastIndex`\ntil 0 før hvert kall.\n\n**Tekst som ser lik ut, men ikke er det.** Navnet André kan lagres med é som ett\nsamlet tegn eller med en vanlig e fulgt av en kombinerende aksent. De to ser\nidentiske ut på skjermen, men POSIX slår fast at matching følger bitmønsteret\nsom brukes til å kode et tegn, ikke den grafiske fremstillingen, og\n`re.search(\"André\", \"Andre\\u0301\")` i Python returnerer `None`. Etter\n`unicodedata.normalize(\"NFC\", ...)` på teksten finner kallet navnet. Normaliser\nmønsteret og teksten til samme form før matching, med `unicodedata.normalize` i\nPython eller `String.prototype.normalize` i JavaScript.\n\n## Les mer\n\n- [The Open Group Base Specifications Issue 8: Regular Expressions](https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap09.html)\n  — POSIX-definisjonen: BRE og ERE, uttrykk i hakeparenteser, tegnklasser og\n  locales, og regelen om leftmost-longest.\n- [regexp package (Go)](https://pkg.go.dev/regexp)\n  — garantien om lineær tid, leftmost-first mot leftmost-longest, og hvorfor\n  CompilePOSIX avviker fra POSIX for deltreff.\n- [re — Regular expression operations (Python)](https://docs.python.org/3/library/re.html)\n  — syntaksen, Unicode- og ASCII-klasser, backtracking og possessive\n  kvantifikatorer, og search, prefixmatch og fullmatch.\n- [ECMAScript: Text Processing (living draft, ECMAScript 2027)](https://tc39.es/ecma262/multipage/text-processing.html)\n  — regulære uttrykk i JavaScript: arven fra Perl 5, definisjonen av `\\d`,\n  Unicode-egenskapsescapes og hvordan lastIndex brukes.\n- [CWE-1333: Inefficient Regular Expression Complexity](https://cwe.mitre.org/data/definitions/1333.html)\n  — catastrophic backtracking og ReDoS: betingelsene som gjør et mønster\n  utnyttbart, observerte eksempler og tiltak.\n\n\u003chttps://engineer.company/nb/glossary/regular-expression/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvordan et regulært uttrykk plukker ut tekststrenger, hvorfor motorer leser samme mønster ulikt, og hvordan backtracking og løse ankre ødelegger validering.","formats":{"gemtext":"https://engineer.company/nb/glossary/regular-expression/index.gmi","gopher":"https://engineer.company/nb/glossary/regular-expression/gophermap","html":"https://engineer.company/nb/glossary/regular-expression/","json":"https://engineer.company/nb/glossary/regular-expression/index.json","markdown":"https://engineer.company/nb/glossary/regular-expression/index.md","pdf":"https://engineer.company/nb/glossary/regular-expression/index.pdf"},"kind":"page","language":"nb","title":"Hva er et regulært uttrykk?","url":"https://engineer.company/nb/glossary/regular-expression/","version":1}