{"canonical_url":"https://engineer.company/sv/glossary/regular-expression/","content_markdown":"# Reguljärt uttryck\n\n## Vad det är\n\nEtt reguljärt uttryck är ett kort mönster som beskriver en mängd textsträngar,\nså att ett program kan välja ut dem som hör dit. POSIX-standarden, som ges ut av\nThe Open Group och IEEE, inleder sitt kapitel i ämnet med att beskriva reguljära\nuttryck som ett sätt att välja ut specifika strängar ur en mängd teckensträngar.\nI vardagligt tal och i namnen på många funktioner och bibliotek krymper\nbegreppet till regex, eller till regexp, som är stavningen i JavaScripts\nRegExp-objekt och i regexp-paketet i Go.\n\nDe flesta tecken i ett mönster står för sig själva: ett `a` i mönstret matchar\nett `a` i texten. Några få är speciella. En punkt matchar vilket tecken som\nhelst, `*` upprepar det som står före noll eller fler gånger, ett uttryck inom\nhakparenteser som `[0-9]` matchar ett tecken ur en mängd, `^` och `$` binder\nmönstret till början och slutet, och ett intervall som `{4}` kräver ett bestämt\nantal upprepningar. Därmed beskriver `^[0-9]{4}$` varje sträng som består av\nexakt fyra siffror, utan andra tecken före eller efter. Standardens eget exempel\npå ett intervall är `c{3}` tillämpat på `abababccccccd`: det matchar det sjunde\ntill nionde tecknet, de tre första av de sex c:na.\n\nDet finns mer än en dialekt. POSIX definierar själv två: grundläggande reguljära\nuttryck (BRE), som de flesta av standardens verktyg använder, och utökade\nreguljära uttryck (ERE), som några använder i stället. C-funktionerna\n`regcomp()` och `regexec()` erbjuder båda. Skillnaden är inte kosmetisk. I ett\nERE betyder `a+` ett eller flera `a`. I ett BRE är `+` ett vanligt tecken, och\nstandarden överlåter åt varje implementation att avgöra om `\\+` betyder ett\neller flera eller ett bokstavligt plustecken.\n\nDen andra stora familjen härstammar från Perl. ECMAScript-specifikationen slår\nfast att formen och funktionaliteten hos reguljära uttryck i JavaScript är\nmodellerade efter funktionaliteten för reguljära uttryck i Perl 5.\nRegexp-paketet i Go beskriver sin syntax som den allmänna syntax som Perl,\nPython och andra språk använder, och `re`-modulen i Python är en tredje medlem.\nDessa motorer delar det mesta av notationen men inte varje detalj.\nFörkortningsklasserna är ett bra exempel: `\\d` (en siffra) och `\\w` (ett\nordtecken) ser likadana ut överallt, men vad de omfattar beror på motorn och\nflaggorna, vilket avsnittet om praktiken nedan visar.\n\n## Varför det spelar roll\n\nReguljära uttryck sitter i mycket mjukvara som inte ser ut som textbehandling:\nvalidering av formulärfält, filter som plockar ut värden ur loggrader,\nroutningsregler i webbservrar, sök och ersätt i textredigerare. Varje mönster är\nkort, och därför är det lätt att förbise vad det faktiskt godtar. Två frågor\navgör resultatet, och svaret på båda beror på motorn: vilken träff som väljs när\nflera är möjliga, och hur lång tid det kan ta att hitta en.\n\nPOSIX väljer den träff som står längst till vänster och bland dem den längsta:\nav alla träffar som börjar tidigast i texten vinner den längsta, på engelska\nleftmost-longest. Standardens exempel är BRE:t `bb*`, som matchar andra till\nfjärde tecknet i `abbbc`, och ERE:t `(wee|week)(knights|night)`, som matchar\nalla tio tecknen i `weeknights`. Perl-familjen arbetar annorlunda. Den prövar\nalternativen i den ordning de är skrivna och tar det första som leder till en\nträff, det som dokumentationen för Go kallar leftmost-first. Samma mönster på\nsamma text kan därför ge två 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 erbjuder båda. Funktionen `Compile` använder leftmost-first, medan\n`CompilePOSIX` begränsar syntaxen till POSIX ERE och byter till\nleftmost-longest. Även då behåller paketet sin egen regel för vilka delträffar\nsom väljs, och dokumentationen förklarar varför: POSIX-regeln är enligt den\noöverkomligt dyr att beräkna och inte ens väldefinierad.\n\nDen andra frågan är tid. `re` i Python backtrackar, liksom de flesta motorer i\nPerl-familjen. När en del av mönstret inte kommer vidare går motorn ett steg\ntillbaka och prövar ett annat sätt att matcha det som kom före. Dokumentationen\nför Python visar idén med `a*a` mot `aaaa`: `a*` tar först alla fyra bokstäverna\noch lämnar sedan tillbaka en, så att det sista `a` kan matcha. För de flesta\nmönster är kostnaden osynlig. För vissa växer antalet sätt att pröva\nexponentiellt med längden på indata, och en sträng på några dussin tecken kan\nhålla en processor sysselsatt i minuter. MITRE katalogiserar detta som CWE-1333,\nInefficient Regular Expression Complexity, och anger ReDoS (regular expression\ndenial of service) och catastrophic backtracking som andra namn på det.\nRegexp-paketet i Go utformades kring det motsatta löftet. Dokumentationen slår\nfast att matchningen garanterat körs i tid som är linjär i förhållande till\nstorleken på indata, och tillägger att de flesta implementationer med öppen\nkällkod inte ger någon sådan garanti.\n\n## Så ser det ut i praktiken\n\nTa ett registreringsformulär för kunder i Danmark och Ukraina, och ett\nförnamnsfält som bara ska godta bokstäver. Det självklara mönstret är\n`[A-Za-z]+`, och i Python 3.15 beter det sig så här:\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\nEtt anrop som returnerar `None` skriver inte ut en enda rad i det interaktiva\nskalet, så ASCII-klassen avvisar Søren och Олена (Olena), två helt vanliga namn\ni Köpenhamn och Kyiv. Byter man till `\\w` släpps de igenom, men i Python\nomfattar `\\w` alla tecken som `str.isalnum()` är sant för, plus understrecket,\nså klassen släpper också in `Søren_42`. Klassen `[^\\W\\d_]` utesluter tecken som\ninte är ordtecken, decimala siffror och understrecket. Den tillåter också vissa\nnumeriska tecken som inte är decimala siffror och är därför inget strikt test\nför enbart bokstäver. För namn på mer än ett ord godtar `[^\\W\\d_]+( [^\\W\\d_]+)*`\nbåde `Anne Sofie Østergaard` och `Олена Коваль`. Mönstret avvisar fortfarande en\n`Anne-Marie` med bindestreck, och det är ett skäl att hålla ett namnfält så\ngeneröst som verksamheten tål. POSIX-verktyg har samma problem i en annan form:\nstandarden lämnar betydelsen av ett teckenintervall som `A-Z` ospecificerad\nutanför POSIX-localen och erbjuder klassen `[[:alpha:]]`, där den aktuella\nlocalen avgör vilka tecken som hör dit.\n\nAtt göra rätt här betyder mer än ett formulär. En av tjänsterna på den här\nwebbplatsen,\n[Internationalisering och lokalisering](/sv/services/i18n-localization/),\nbeskriver målet som mjukvara som känns naturlig på varje marknad kunden säljer\npå, inklusive hur namn sorteras. Ett namnfält som avvisar Søren brister långt\ninnan någon sortering sker.\n\nSiffror väcker den motsatta frågan. Ett danskt postnummer består av fyra\nsiffror, så `\\d{4}` ser ut som en säker kontroll av `2200`. I Python matchar\n`\\d` i ett textmönster ändå varje decimalsiffra i Unicode, inte bara 0 till 9,\noch godtar samma postnummer skrivet med arabisk-indiska siffror:\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å andra sidan. ECMAScript-specifikationen definierar `\\d` som\nexakt de tio tecknen 0 till 9, så `/^\\d{4}$/.test(s)` returnerar `false` i\nNode.js för samma sträng, medan `/^\\p{Nd}{4}$/u` returnerar `true`. Ett formulär\nsom kontrolleras i webbläsaren med den ena regeln och på servern med den andra\nkommer att vara oense med sig självt om samma indata. `int()` i Python läser\nsträngen som 2200, men en databaskolumn, en uppslagstabell eller en annan tjänst\ngör det kanske inte. Bestäm vilka siffror som avses: `[0-9]` eller flaggan\n`re.ASCII` när bara ASCII-siffror räcker, och `\\p{Nd}` med flaggan `u` i\nJavaScript när varje decimalsiffra är välkommen.\n\n## Var det går fel\n\n**Ett mönster som fördubblar tiden för varje bokstav.** Ett namnmönster som ska\ntillåta ord åtskilda av enkla mellanslag skrivs lätt som `([^\\W\\d_]+ ?)+`. På\nett giltigt namn är det snabbt. På en följd av bokstäver med ett tecken det inte\nkan godta på slutet prövar motorn alla sätt att dela in bokstäverna i ord innan\nden ger upp, och antalet sätt fördubblas för varje bokstav. På en maskin med\nPython 3.15 gav den snabbaste av fem körningar för varje längd de här tiderna\nför `fullmatch` på en sträng av bokstäver följd 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\nVarje bokstav fördubblar tiden, så två bokstäver till fyrdubblar den. Räknar man\nvidare med den faktorn skulle trettio bokstäver ta ungefär en minut och\ntrettiotvå mer än fyra minuter. Det här är fallet som CWE-1333 beskriver:\nbacktracking-försöken växer exponentiellt med indata, indata behöver inte\nmatcha, och indata kan vara tillräckligt lång. Omskrivningen\n`[^\\W\\d_]+( [^\\W\\d_]+)*` beskriver samma namn utan en nästlad kvantifierare,\navvisar strängen på 24 bokstäver på ungefär en mikrosekund och en miljon\nbokstäver följda av `!` på ungefär trettio millisekunder. Ta bort nästlade\nkvantifierare, begränsa längden på indata innan den matchas, och kör mönster som\ntar emot opålitlig indata i en motor med garanterat linjär tid, som den i Go.\n\n**Sökning där hela värdet ska matcha.** I Python godtar `re.search` en träff var\nsom helst i strängen, och `re.match` förankrar bara i början; Python 3.15 ger\nden det tydligare namnet `prefixmatch` och markerar det gamla namnet som soft\ndeprecated, med en anmärkning om att andra språk använder match för det som\nPython alltid har kallat search. Därmed lyckas\n`re.prefixmatch(r\"\\d{4}\", \"22000\")` på de fyra första siffrorna, och\n`re.search(r\"\\d{4}\", \"DK-2200\")` hittar postnumret inne i strängen. Till och med\n`re.search(r\"^\\d{4}$\", \"2200\\n\")` lyckas, eftersom `$` också matchar precis före\nen radbrytning i slutet. `re.fullmatch`, som har funnits sedan Python 3.4,\navvisar alla tre. Använd `fullmatch` när ett mönster beskriver hela värdet,\neller förankra med `\\A` och `\\Z`, som Python 3.14 också stavar `\\z`.\n\n**En tillåtelselista med en lös punkt.** En kontroll som bara släpper igenom\nomdirigeringar till företagets egen webbplats kan skrivas som\n`^https://www.example.com`. Den godtar `https://www.example.com.evil.example/`,\neftersom mönstret tar slut innan värdnamnet gör det, och varje punkt utan escape\nmatchar vilket tecken som helst, så en värd som skiljer sig från den riktiga med\nett enda tecken i stället för en punkt släpps också igenom. Att escapa\npunkterna, som `re.escape(\"www.example.com\")` gör, och avsluta mönstret med `/`\ntäpper till båda hålen. Ännu bättre: parsa URL:en och jämför värdnamnet med det\nförväntade som en hel sträng.\n\n**Ett mönster som flyttas mellan motorer.** Ett mönster som har testats med\n`grep -E` och klistrats in i Python kan välja en annan träff, som exemplet med\n`a|ab` visar, och ett som fungerar i ett BRE-verktyg med `\\+` kan betyda ett\nbokstavligt plustecken i ett annat. Samma `\\d` som godtar arabisk-indiska\nsiffror i Python avvisar dem i JavaScript. Testa varje mönster i den motor som\nska köra det, med de flaggor det ska köras med.\n\n**En global flagga som minns.** I JavaScript sparar ett reguljärt uttryck med\nflaggan `g` eller `y` positionen där den senaste träffen slutade i `lastIndex`\noch börjar nästa sökning där; efter ett misslyckat försök nollställs `lastIndex`\ntill 0. Ett mönster som ligger i en konstant och återanvänds för validering\nsvarar då olika varannan gång:\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\nUtelämna flaggan `g` på mönster som används med `test()`, eller sätt `lastIndex`\ntill 0 före varje anrop.\n\n**Text som ser likadan ut men inte är det.** Namnet André kan lagras med é som\nett sammansatt tecken eller med ett vanligt e följt av en kombinerande accent.\nDe två ser identiska ut på skärmen, men POSIX slår fast att matchning följer det\nbitmönster som används för att koda ett tecken, inte den grafiska återgivningen,\noch `re.search(\"André\", \"Andre\\u0301\")` i Python returnerar `None`. Efter\n`unicodedata.normalize(\"NFC\", ...)` på texten hittar anropet namnet. Normalisera\nmönstret och texten till samma form före matchning, med `unicodedata.normalize`\ni Python eller `String.prototype.normalize` i JavaScript.\n\n## Läs mer\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 och ERE, uttryck inom hakparenteser, teckenklasser\n  och locales, samt regeln om leftmost-longest.\n- [regexp package (Go)](https://pkg.go.dev/regexp)\n  — garantin om linjär tid, leftmost-first mot leftmost-longest, och varför\n  CompilePOSIX avviker från POSIX för delträffar.\n- [re — Regular expression operations (Python)](https://docs.python.org/3/library/re.html)\n  — syntaxen, Unicode- och ASCII-klasser, backtracking och possessiva\n  kvantifierare, samt search, prefixmatch och fullmatch.\n- [ECMAScript: Text Processing (living draft, ECMAScript 2027)](https://tc39.es/ecma262/multipage/text-processing.html)\n  — reguljära uttryck i JavaScript: arvet från Perl 5, definitionen av `\\d`,\n  Unicode-egenskapsescapes och hur lastIndex används.\n- [CWE-1333: Inefficient Regular Expression Complexity](https://cwe.mitre.org/data/definitions/1333.html)\n  — catastrophic backtracking och ReDoS: villkoren som gör ett mönster\n  utnyttjbart, observerade exempel och åtgärder.\n\n\u003chttps://engineer.company/sv/glossary/regular-expression/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hur ett reguljärt uttryck väljer ut textsträngar, varför motorer läser samma mönster olika och hur backtracking och lösa ankare förstör validering.","formats":{"gemtext":"https://engineer.company/sv/glossary/regular-expression/index.gmi","gopher":"https://engineer.company/sv/glossary/regular-expression/gophermap","html":"https://engineer.company/sv/glossary/regular-expression/","json":"https://engineer.company/sv/glossary/regular-expression/index.json","markdown":"https://engineer.company/sv/glossary/regular-expression/index.md","pdf":"https://engineer.company/sv/glossary/regular-expression/index.pdf"},"kind":"page","language":"sv","title":"Vad är ett reguljärt uttryck?","url":"https://engineer.company/sv/glossary/regular-expression/","version":1}