Girig vs lat matchning i regex: varför ditt mönster fångar för mycket

Du skriver <b>.*</b> för att fånga innehållet i en fetstilstagg, testar den på <b>Hello</b>, och den fungerar perfekt. Sedan kör du den på riktig HTML med två fetstilstaggar på samma rad — <b>Hello</b> and <b>World</b> — och istället för två träffar får du en enda jättematchning som spänner över båda taggarna. Det här är inte en bugg i din regex-motor; det är standardbeteendet hos *, + och {n,m}, och det finns en lösning på ett enda tecken när du väl förstår vad som händer.

Varför .* fångar mer än du förväntar dig

Som standard är kvantifierare i regex giriga — .* betyder inte “matcha några tecken”, det betyder “matcha så många tecken som möjligt, och backa bara om resten av mönstret absolut kräver det.”

Gå igenom <b>.*</b> mot <b>Hello</b> and <b>World</b> steg för steg:

1. <b> matchar den första <b>.
2. .* börjar med att konsumera hela resten av strängen — allt fram till slutet, inklusive den andra <b>World</b>.
3. Motorn behöver sedan hitta </b> för att avsluta matchningen, så den börjar backa från slutet av .* ett tecken i taget.
4. Den första platsen (räknat bakifrån) där </b> passar är den allra sista </b> i strängen — inte den första den “logiskt” borde stanna vid.

Så matchningen blir i sin helhet <b>Hello</b> and <b>World</b>, eftersom girig matchning alltid först försöker med den längsta möjliga strängen och bara krymper den så lite som möjligt för att resten av mönstret ska lyckas.

Lösningen: gör kvantifieraren lat med ?

Att lägga till ett ? direkt efter en kvantifierare vänder den från girig till lat (kallas även “icke-girig” eller “återhållsam”): *?, +?, ??, {n,m}?.

En lat kvantifierare gör motsatsen: den börjar med att matcha så få tecken som möjligt, och utökar bara om resten av mönstret ännu inte kan lyckas.

<b>.*?</b> mot samma sträng:

1. <b> matchar den första <b>.
2. .*? börjar med att matcha noll tecken.
3. Motorn kontrollerar: matchar </b> precis här? Nej (vi är vid “Hello…”, inte ännu vid en </b>) — så den utökar .*? med exakt ett tecken och kontrollerar igen.
4. Detta upprepas tecken för tecken tills .*? har konsumerat exakt Hello, och då matchar </b> omedelbart.

Resultat: <b>Hello</b> och <b>World</b> kommer tillbaka som två separata matchningar, vilket nästan alltid är det du faktiskt ville ha när du tolkar tagg-liknande eller avgränsar-liknande strukturer.

När du faktiskt vill ha girig matchning (det är inte bara “fel standard”)

Girig matchning är inget misstag i språket — det är korrekt för ett annat, lika vanligt fall: att matcha den yttersta gränsen av något, inte den minsta enheten inuti det. Om du extraherar “allt mellan den första { och den sista }” i en klump JSON-liknande text (till exempel för att fånga ett helt objekt oavsett nästling), är girig matchning precis rätt, och lat matchning skulle istället stanna vid den första inre }, vilket ger dig ett avkortat, ogiltigt fragment.

Tumregeln: lat för upprepade små avgränsade bitar (taggar, citerade strängar, listobjekt); girig för “fånga hela det yttre spannet.”

Snabbreferens

Mönster	Beteende	Använd när
.*, .+, {n,m}	Girig — matchar längsta möjliga	Du vill ha det yttersta spannet, eller det bara finns en matchning i strängen
.*?, .+?, {n,m}?	Lat — matchar kortaste möjliga	Du har flera liknande avgränsade bitar och vill ha var och en separat

Om du är osäker på vad ett mönster faktiskt gör på din riktiga indata snarare än din teststräng, gör det direkt synligt att köra det mot den riktiga texten med flera matchningar i en regex-testare med live-markering av matchningar — du ser ett enda jättestort markerat block för girig matchning jämfört med flera separata för lat, vilket oftast går snabbare än att resonera sig fram tecken för tecken.