{"canonical_url":"https://engineer.company/da/glossary/regular-expression/","content_markdown":"# Regulært udtryk\n\n## Hvad det er\n\nEt regulært udtryk er et kort mønster, der beskriver en mængde tekststrenge, så\net program kan udvælge dem, der hører til. POSIX-standarden, som The Open Group\nog IEEE udgiver, indleder sit kapitel om emnet med at beskrive regulære udtryk\nsom en måde at udvælge bestemte strenge fra en mængde af tegnstrenge. I daglig\ntale og i mange funktions- og biblioteksnavne skrumper betegnelsen til regex\neller til regexp, som er stavemåden i JavaScripts RegExp-objekt og i\nregexp-pakken i Go.\n\nDe fleste tegn i et mønster står for sig selv: et `a` i mønsteret matcher et `a`\ni teksten. Nogle få er særlige. Et punktum matcher et vilkårligt tegn, `*`\ngentager det foregående nul eller flere gange, et udtryk i kantede parenteser\nsom `[0-9]` matcher ét tegn fra en mængde, `^` og `$` binder mønsteret til\nstarten og slutningen, og et interval som `{4}` kræver et bestemt antal\ngentagelser. Så `^[0-9]{4}$` beskriver enhver streng, der består af præcis fire\ncifre, uden andre tegn før eller efter. Standardens eget eksempel på et interval\ner `c{3}` anvendt på `abababccccccd`: det matcher det syvende til niende tegn,\nde første tre af de seks c'er.\n\nDer findes mere end én dialekt. POSIX definerer selv to: basale regulære udtryk\n(BRE), som de fleste af standardens værktøjer bruger, og udvidede regulære\nudtryk (ERE), som nogle bruger i stedet. C-funktionerne `regcomp()` og\n`regexec()` tilbyder begge. Forskellen er ikke kosmetisk. I et ERE betyder `a+`\nét eller flere `a`. I et BRE er `+` et almindeligt tegn, og standarden overlader\ndet til hver implementering, om `\\+` betyder ét eller flere eller et\nbogstaveligt plustegn.\n\nDen anden store familie nedstammer fra Perl. ECMAScript-specifikationen\nfastslår, at formen og funktionaliteten af JavaScripts regulære udtryk er\nmodelleret efter Perl 5's faciliteter til regulære udtryk. Regexp-pakken i Go\nbeskriver sin syntaks som den generelle syntaks, som Perl, Python og andre sprog\nbruger, og Pythons `re`-modul er et tredje medlem. Motorerne deler det meste af\nnotationen, men ikke alle detaljer. Forkortelsesklasserne er et godt eksempel:\n`\\d` (et ciffer) og `\\w` (et ordtegn) ser ens ud overalt, men hvad de dækker,\nafhænger af motoren og dens flag, som afsnittet om praksis nedenfor viser.\n\n## Hvorfor det betyder noget\n\nRegulære udtryk sidder i en stor del af den software, der ikke ligner\nbearbejdning af tekst: validering af formularfelter, filtre, der trækker værdier\nud af loglinjer, routingregler i webservere, søg og erstat i teksteditorer.\nHvert mønster er kort, og derfor er det let at overse, hvad det faktisk\naccepterer. To spørgsmål afgør resultatet, og svaret på begge afhænger af\nmotoren: hvilket match der vælges, når flere er mulige, og hvor lang tid det må\ntage at finde et.\n\nPOSIX vælger det match, der står længst til venstre, og blandt dem det længste:\naf alle de match, der begynder tidligst i teksten, vinder det længste, på\nengelsk leftmost-longest. Standardens eksempler er BRE'et `bb*`, der matcher\nandet til fjerde tegn i `abbbc`, og ERE'et `(wee|week)(knights|night)`, der\nmatcher alle ti tegn i `weeknights`. Perl-familien arbejder anderledes. Den\nprøver alternativerne i den rækkefølge, de står skrevet, og tager det første,\nder fører til et match, hvad dokumentationen til Go kalder leftmost-first. Det\nsamme mønster på den samme tekst kan derfor give 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 tilbyder begge opførsler. Funktionen `Compile` bruger leftmost-first, mens\n`CompilePOSIX` begrænser syntaksen til POSIX ERE og skifter til\nleftmost-longest. Selv da beholder pakken sin egen regel for, hvilke delmatch\nder vælges, og dokumentationen forklarer hvorfor: POSIX-reglen er ifølge den\nberegningsmæssigt uoverkommelig og ikke engang veldefineret.\n\nDet andet spørgsmål er tid. Pythons `re` backtracker ligesom de fleste motorer i\nPerl-familien. Når en del af mønsteret ikke kan komme videre, går motoren et\nskridt tilbage og prøver en anden måde at matche det foregående på. Pythons\ndokumentation viser idéen med `a*a` mod `aaaa`: `a*` tager først alle fire\nbogstaver og giver derefter ét tilbage, så det sidste `a` kan matche. For de\nfleste mønstre er omkostningen usynlig. For nogle vokser antallet af måder at\nprøve eksponentielt med inputtets længde, og en streng på et par dusin tegn kan\nholde en processor beskæftiget i minutvis. MITRE katalogiserer dette som\nCWE-1333, Inefficient Regular Expression Complexity, og nævner ReDoS (regular\nexpression denial of service) og catastrophic backtracking som andre navne for\ndet. Regexp-pakken i Go blev designet omkring det modsatte løfte.\nDokumentationen fastslår, at matchningen garanteret kører i tid, der er lineær i\ninputtets størrelse, og tilføjer, at de fleste open source-implementeringer ikke\ngiver en sådan garanti.\n\n## Sådan ser det ud i praksis\n\nTag en tilmeldingsformular til kunder i Danmark og Ukraine og et fornavnefelt,\nder kun skal acceptere bogstaver. Det oplagte mønster er `[A-Za-z]+`, og i\nPython 3.15 opfører det sig sådan her:\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 kald, der returnerer `None`, udskriver slet ingen linje i den interaktive\nskal, så ASCII-klassen afviser Søren og Олена (Olena), to helt almindelige navne\ni København og Kyiv. Skifter man til `\\w`, kommer de igennem, men i Python\ndækker `\\w` alle tegn, som `str.isalnum()` er sand for, plus understregningen,\nså klassen lukker også `Søren_42` ind. Klassen `[^\\W\\d_]` udelukker tegn, der\nikke er ordtegn, decimalcifre og understregningen. Den tillader også visse\nnumeriske tegn, som ikke er decimalcifre, og er derfor ikke en streng test for\nudelukkende bogstaver. Til navne på mere end ét ord accepterer\n`[^\\W\\d_]+( [^\\W\\d_]+)*` både `Anne Sofie Østergaard` og `Олена Коваль`.\nMønsteret afviser stadig et `Anne-Marie` med bindestreg, og det er en grund til\nat holde et navnefelt så rummeligt, som forretningen kan bære. POSIX-værktøjer\nhar samme problem i en anden form: standarden lader betydningen af et tegnområde\nsom `A-Z` være uspecificeret uden for POSIX-localet og tilbyder klassen\n`[[:alpha:]]`, hvis medlemmer bestemmes af det aktuelle locale.\n\nAt få det rigtigt betyder mere end den ene formular. En af dette websteds\nydelser, [Internationalisering \u0026 lokalisering](/da/services/i18n-localization/),\nbeskriver målet som software, der læses naturligt på hvert marked, man sælger\npå, helt ned til den måde, navne sorteres på. Et navnefelt, der afviser Søren,\nsvigter det mål længe før nogen sortering finder sted.\n\nCifre rejser det modsatte spørgsmål. Et dansk postnummer består af fire cifre,\nså `\\d{4}` ligner en sikker kontrol af `2200`. I Python matcher `\\d` i et\ntekstmønster dog ethvert decimalciffer i Unicode, ikke kun 0 til 9, og\naccepterer det samme postnummer skrevet med arabisk-indiske cifre:\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 anden side. ECMAScript-specifikationen definerer `\\d` som\npræcis de ti tegn 0 til 9, så `/^\\d{4}$/.test(s)` returnerer `false` i Node.js\nfor den samme streng, mens `/^\\p{Nd}{4}$/u` returnerer `true`. En formular, der\nkontrolleres i browseren med den ene regel og på serveren med den anden, vil\nvære uenig med sig selv om det samme input. Pythons `int()` læser strengen som\n2200, men en databasekolonne, en opslagstabel eller en anden tjeneste gør det\nmåske ikke. Beslut, hvilke cifre der menes: `[0-9]` eller flaget `re.ASCII`, når\nkun ASCII-cifre duer, og `\\p{Nd}` med flaget `u` i JavaScript, når ethvert\ndecimalciffer er velkomment.\n\n## Hvor det går galt\n\n**Et mønster, der fordobler tiden for hvert bogstav.** Et navnemønster, der skal\ntillade ord adskilt af enkelte mellemrum, skrives let som `([^\\W\\d_]+ ?)+`. På\net gyldigt navn er det hurtigt. På en række bogstaver efterfulgt af et tegn, det\nikke kan acceptere, prøver motoren alle måder at dele bogstaverne op i ord, før\nden giver op, og antallet af måder fordobles for hvert bogstav. På én maskine\nmed Python 3.15 gav den hurtigste af fem kørsler ved hver længde disse tider for\n`fullmatch` på en streng af bogstaver efterfulgt af `!`:\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\nHvert bogstav fordobler tiden, så to bogstaver mere firedobler den. Fremskrevet\nmed den faktor ville tredive bogstaver tage omkring et minut og toogtredive mere\nend fire minutter. Det er netop det tilfælde, CWE-1333 beskriver: forsøgene på\nbacktracking vokser eksponentielt med inputtet, inputtet behøver ikke at matche,\nog inputtet kan være langt nok. Omskrivningen `[^\\W\\d_]+( [^\\W\\d_]+)*` beskriver\nde samme navne uden en indlejret kvantor og afviser strengen på 24 bogstaver på\nomkring et mikrosekund og en million bogstaver efterfulgt af `!` på omkring\ntredive millisekunder. Fjern indlejrede kvantorer, begræns inputtets længde, før\ndet matches, og kør mønstre, der ser input, man ikke kan stole på, på en motor\nmed en garanti for lineær tid, som den i Go.\n\n**Søgning, hvor hele værdien skal matche.** I Python accepterer `re.search` et\nmatch hvor som helst i strengen, og `re.match` forankrer kun i starten; Python\n3.15 giver den det tydeligere navn `prefixmatch` og markerer det gamle navn som\nsoft deprecated med den bemærkning, at andre sprog bruger match om det, Python\naltid har kaldt search. Så `re.prefixmatch(r\"\\d{4}\", \"22000\")` lykkes på de\nførste fire cifre, og `re.search(r\"\\d{4}\", \"DK-2200\")` finder postnummeret inde\ni strengen. Selv `re.search(r\"^\\d{4}$\", \"2200\\n\")` lykkes, fordi `$` også\nmatcher lige før et linjeskift i slutningen. `re.fullmatch`, der har fandtes\nsiden Python 3.4, afviser alle tre. Brug `fullmatch`, når et mønster beskriver\nhele værdien, eller forankr med `\\A` og `\\Z`, som Python 3.14 også staver `\\z`.\n\n**En tilladelsesliste med et løst punktum.** En kontrol, der kun lader\nomdirigeringer gå til virksomhedens eget websted, kunne skrives som\n`^https://www.example.com`. Den accepterer\n`https://www.example.com.evil.example/`, fordi mønsteret holder op, før\nværtsnavnet gør, og hvert punktum uden escape matcher et vilkårligt tegn, så en\nvært, der adskiller sig fra den rigtige ved ét enkelt tegn i stedet for et\npunktum, også slipper igennem. At escape punktummerne, som\n`re.escape(\"www.example.com\")` gør, og afslutte mønsteret med `/` lukker begge\nhuller. Eller bedre: parse URL'en, og sammenlign dens værtsnavn med det\nforventede som en hel streng.\n\n**Et mønster, der flyttes mellem motorer.** Et mønster, der er testet med\n`grep -E` og sat ind i Python, kan vælge et andet match, som eksemplet med\n`a|ab` viser, og et, der virker i ét BRE-værktøj med `\\+`, kan betyde et\nbogstaveligt plustegn i et andet. Det `\\d`, der accepterer arabisk-indiske cifre\ni Python, afviser dem i JavaScript. Test hvert mønster i den motor, der skal\nkøre det, med de flag, det skal køre med.\n\n**Et globalt flag, der husker.** I JavaScript gemmer et regulært udtryk med\nflaget `g` eller `y` positionen, hvor dets seneste match sluttede, i `lastIndex`\nog starter næste søgning dér; efter et mislykket forsøg nulstiller det\n`lastIndex` til 0. Et mønster, der ligger i en konstant og genbruges til\nvalidering, svarer så forskelligt ved hvert andet kald:\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\nUdelad flaget `g` på mønstre, der bruges med `test()`, eller sæt `lastIndex` til\n0 før hvert kald.\n\n**Tekst, der ser ens ud, men ikke er det.** Navnet André kan gemmes med é som ét\nsamlet tegn eller med et almindeligt e efterfulgt af en kombinerende accent. De\nto ser identiske ud på skærmen, men POSIX fastslår, at matchning følger det\nbitmønster, der bruges til at kode et tegn, ikke dets grafiske fremtræden, og\nPythons `re.search(\"André\", \"Andre\\u0301\")` returnerer `None`. Efter\n`unicodedata.normalize(\"NFC\", ...)` på teksten finder kaldet navnet. Normalisér\nmønsteret og teksten til samme form før matchning, med `unicodedata.normalize` i\nPython eller `String.prototype.normalize` i JavaScript.\n\n## Læs mere\n\n- [The Open Group Base Specifications Issue 8: Regular Expressions](https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap09.html)\n  — POSIX-definitionen: BRE og ERE, udtryk i kantede parenteser, tegnklasser og\n  locales samt reglen om leftmost-longest.\n- [regexp package (Go)](https://pkg.go.dev/regexp)\n  — garantien for lineær tid, leftmost-first over for leftmost-longest, og\n  hvorfor CompilePOSIX afviger fra POSIX ved delmatch.\n- [re — Regular expression operations (Python)](https://docs.python.org/3/library/re.html)\n  — syntaksen, Unicode- og ASCII-klasser, backtracking og possessive kvantorer\n  samt search, prefixmatch og fullmatch.\n- [ECMAScript: Text Processing (living draft, ECMAScript 2027)](https://tc39.es/ecma262/multipage/text-processing.html)\n  — JavaScripts regulære udtryk: arven fra Perl 5, definitionen af `\\d`,\n  Unicode-egenskabsescapes og hvordan lastIndex bruges.\n- [CWE-1333: Inefficient Regular Expression Complexity](https://cwe.mitre.org/data/definitions/1333.html)\n  — catastrophic backtracking og ReDoS: de betingelser, der gør et mønster\n  udnytteligt, observerede eksempler og modforholdsregler.\n\n\u003chttps://engineer.company/da/glossary/regular-expression/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvordan et regulært udtryk udvælger tekststrenge, hvorfor motorer læser samme mønster forskelligt, og hvordan backtracking og løse ankre bryder validering.","formats":{"gemtext":"https://engineer.company/da/glossary/regular-expression/index.gmi","gopher":"https://engineer.company/da/glossary/regular-expression/gophermap","html":"https://engineer.company/da/glossary/regular-expression/","json":"https://engineer.company/da/glossary/regular-expression/index.json","markdown":"https://engineer.company/da/glossary/regular-expression/index.md","pdf":"https://engineer.company/da/glossary/regular-expression/index.pdf"},"kind":"page","language":"da","title":"Hvad er et regulært udtryk?","url":"https://engineer.company/da/glossary/regular-expression/","version":1}