Naar de inhoud
OneKitly

Zoeken en vervangen: de regexfuncties die bijten, één voor één gedemonstreerd

Gepubliceerd op 30-5-2025 · 14 min leestijd · Tekst- & taaltools

Daniel Okonkwo

Daniel Okonkwo — Front-enddeveloper en techredacteur bij OneKitly

Webprestaties · Bestandsformaten

Getoetst aan 5 bronnen

Profiel bekijken →
Kort gezegd

De manieren waarop zoeken en vervangen misgaat zijn specifiek en reproduceerbaar, dus kunnen ze worden gedemonstreerd in plaats van aangekondigd. Quantoren zijn standaard gulzig: op „<b>bold</b> and <i>italic</i>” geeft /<.+>/g door niets vervangen een lege tekenreeks terug, want .+ loopt door tot de laatste > in de regel; de luie /<.+?>/g en de ontkende /<[^>]+>/g geven beide „bold and italic” terug. De punt matcht nooit een regeleinde tenzij de vlag s staat: /Price.*units/ is onwaar over twee regels en /Price.*units/s is waar. De vervangingstekenreeks heeft haar eigen syntaxis, zonder verband met het patroon: $& voegt de hele match in, $1 een groep, en $$ is de enige manier om een letterlijk dollarteken af te geven — „$$$1” op „Totaal: 42 EUR” geeft „Totaal: $42” terwijl „$$&” het letterlijke „$&” geeft. Een regexobject met de vlag g houdt een lastIndex tussen aanroepen bij, dus slaat er een hergebruiken over rijen heen matches over: dezelfde /\d+/g, getest tegen drie orderregels, gaf waar, onwaar, waar. En /i is pure case folding en geen talenkennis: /i/i matcht İ niet, en /I/i matcht ı niet. Tel eerst de matches, vervang dan.

Advertentie

Gulzig tegen lui op dezelfde tekenreeks, de punt die regeleindes overslaat, $& en $$ in de vervanging, een hergebruikte /g-regex die stil een regel overslaat, en waarom /i niets weet over de Turkse i. Elke storing in Node uitgevoerd, met een routine die eerst telt en dan vervangt en ze betrapt.

Gulzig en lui op dezelfde invoer

Neem de tekenreeks <b>bold</b> and <i>italic</i> en probeer de tags te verwijderen met /<.+>/g. Het resultaat is een lege tekenreeks. De quantor + is gulzig: hij neemt zoveel als hij kan en geeft tekens pas terug als de rest van het patroon faalt, dus slokt .+ alles op tot de laatste > en dekt één enkele match de hele regel. De eerste match van /<.+>/ is letterlijk de hele invoer.

Twee bewerkingen repareren het en ze zijn niet gelijkwaardig. Een vraagteken toevoegen maakt de quantor lui: /<.+?>/g neemt zo weinig als hij kan, zijn eerste match is <b>, en de vervanging geeft bold and italic terug. De punt door een ontkende klasse vervangen doet hetzelfde werk anders: /<[^>]+>/g kan een > helemaal niet oversteken, dus geeft hij ook bold and italic terug. Verkies de ontkende klasse waar er een bestaat — die zegt wat de grens is in plaats van op het terugkrabbelen van de engine te vertrouwen om op de juiste plek te stoppen, en hij wordt niet stil weer gulzig als je later een optioneel deel aan het patroon toevoegt.

Advertentie

De punt stopt aan het eind van de regel

In JavaScript matcht . elk teken behalve een regeleindeteken. Neem een record van twee regels: „Price: $12.50”, dan een regeleinde, dan „Stock: 3 units”. De test /Price.*units/ geeft onwaar terug. Hetzelfde patroon met de vlag s, /Price.*units/s, geeft waar terug, want s — dotAll — haalt de uitzondering voor het regeleinde weg. De oudere omweg, een tekenklasse die alles dekt, /Price[\s\S]*units/, geeft ook waar terug en werkt in runtimes die ouder zijn dan de vlag.

Hier gaat een vervanging stil mis in plaats van luid. Een patroon dat een alinea moest overspannen vindt simpelweg niets, het aantal vervangingen komt terug als nul, en een pijplijn die het aantal niet controleert meldt succes. Het is ook de reden dat /.+/g een bruikbare regelsplitser is: op hetzelfde record van twee regels geeft hij twee matches terug, één per regel, en dat is een functie als je het wil en een verrassing als je het niet wil.

De vervangingstekenreeks heeft haar eigen syntaxis

Het tweede argument van replace is geen gewone tekst. Het is een kleine taal, en haar enige metateken is $. Op „Totaal: 42 EUR” met /(\d+) (USD|EUR)/ geeft de vervanging [$&] „Totaal: [42 EUR]”, geeft $1 „Totaal: 42”, en geeft $<amount> — met de groep benoemd in het patroon — „Totaal: [42]”. De volledige lijst is kort: $&, $1 tot $99, $<naam>, $` voor alles wat aan de match voorafgaat, $' voor alles wat erop volgt, en $$ voor een letterlijk dollarteken.

Daar volgen twee valkuilen uit. De eerste: de $ van een vervanging is niet de $ van een patroon. In een patroon is $ een anker dat einde-van-invoer betekent; in een vervanging betekent hij dat nooit. $ schrijven waar je een valutateken wil, levert alleen bij geluk een letterlijke $ op — replace(/EUR/, "$") geeft werkelijk „Totaal: 42 $”, want een losse $ gevolgd door niets bijzonders gaat er onveranderd door, maar zodra er een cijfer of een ampersand op volgt, verandert de betekenis. Schrijf $$ en denk er niet meer aan.

De tweede valkuil is een dubbelzinnigheid van cijfers. $10 betekent groep 10 als het patroon tien capturegroepen heeft, en groep 1 gevolgd door het teken 0 als het die niet heeft: op een patroon met tien groepen gaf de vervanging [$10] [j] terug, en op een patroon met één groep gaf ze [a0] terug. De betekenis van je vervangingstekenreeks hangt dus af van hoeveel groepen het patroon toevallig bevat — voeg een groep toe en de vervanging verandert van gedrag zonder dat ze is bewerkt. Benoemde groepen halen de dubbelzinnigheid volledig weg, en is de vervanging data in plaats van code, geef dan een functie door: haar retourwaarde wordt letterlijk ingevoegd, dus levert replace(/\d+/, () => "$&") op „Totaal: 42 EUR” het letterlijke „$&” op in plaats van het gevonden getal.

Een /g-regex onthoudt waar hij is gestopt

Een RegExp-object met de vlag g draagt een veranderlijke eigenschap lastIndex, en .test() en .exec() lezen die beide en schrijven haar beide. Hergebruik hetzelfde object over verschillende tekenreeksen en het begint elke zoektocht waar de vorige eindigde. Neem const re = /\d+/g en test hem tegen drie rijen — „order 12”, „order 7”, „order 349” — en de uitkomsten zijn waar, onwaar, waar. In de middelste rij staat een getal. Hij is overgeslagen omdat lastIndex 8 was toen de zoektocht erin begon, en na de derde aanroep was lastIndex 9.

Hetzelfde effect duikt op bij één tekenreeks. Vier opeenvolgende aanroepen re.test("banana") met /a/g geven waar, waar, waar, onwaar: drie a's, dan een mislukte zoektocht die lastIndex op 0 zet, zodat een vijfde aanroep weer waar zou geven. Niets hieraan is een fout — het is wat exec() bruikbaar maakt in een while-lus — maar het maakt een regexconstante op moduleniveau een vermomde gedeelde veranderlijke.

Drie oplossingen, in orde van voorkeur. Zet g niet op een regex die je met .test() gebruikt: de vlag voegt daar niets toe en veroorzaakt alles hierboven. Gebruik matchAll of match met g als je elk voorkomen wil, want beide regelen de index voor je. Of, moet je echt een object hergebruiken, zet re.lastIndex = 0 vóór elke zoektocht, en weet dat je de kwetsbare optie hebt gekozen.

Ongevoelig voor hoofdletters is niet talenkennis

De vlag i past Unicode case folding toe, en dat is een vaste tabel en geen regel van een taal. Het helderste tegenvoorbeeld is het Turks, waar het alfabet twee i's heeft: de i met punt i/İ en de i zonder punt ı/I. Laat de tests lopen en /i/i matcht İ niet, en /I/i matcht ı niet — beide geven onwaar. Intussen geeft "I".toLowerCase() "i" terug maar geeft "I".toLocaleLowerCase("tr") "ı" terug, en geeft "i".toLocaleUpperCase("tr") "İ" terug. De casefuncties kun je over een locale vertellen. De regexvlag niet.

Nog drie uitkomsten uit dezelfde ronde, die elk iemand een ochtend hebben gekost. /ss/i matcht ß niet en /ß/i matcht SS niet, want case folding is een afbeelding van één teken op één teken en de Duitse ringel-s klapt uit naar twee letters. /k/i matcht het kelvinteken K niet, maar /k/iu — met de Unicode-vlag — wel, want de vlag u zet eenvoudige case folding aan, zodat een vlag die er puur syntactisch uitziet verandert welke tekens als gelijk gelden. En /é/i matcht een gedecomponeerde É niet, een e gevolgd door een combinerend accent aigu: case folding is geen normalisatie, en de twee zijn onafhankelijke besluiten, zoals het artikel over accenten in deze reeks uitvoeriger uitwerkt.

Ankeren, en waarom \b liegt over woorden met accenten

\b is geen teken. Het is een assertie met nulbreedte die slaagt waar een woordteken (in JavaScript: [A-Za-z0-9_]) aan precies één kant staat. Die definitie is puur ASCII, en ze levert een uitkomst op die voor elke taal met diakritische tekens precies omgekeerd is. /\bcafé\b/ matcht „un café noir” niet, want na é — dat geen woordteken is — komt een spatie, die er ook geen is, dus is er geen grens. Hetzelfde patroon matcht wél „un cafés”, want é wordt gevolgd door s en dat is een grens. De assertie gaat af waar het woord doorgaat en faalt waar het eindigt.

De vervanging voor \b is een paar Unicode-lookarounds: /(?<![\p{L}\p{N}])café(?![\p{L}\p{N}])/u matcht „un café noir” en weigert „un cafés”, en dat is wat een mens met een heel woord bedoelt. De vlag u is vereist om \p{…} überhaupt te laten herkennen. Is het woord dat je vervangt puur ASCII, dan blijft \b prima — /\bkat\b/ gedraagt zich — maar zodra het patroon een letter buiten A–Z bevat, controleer dan beide uiteinden met de hand.

Tellen en dan vervangen: een uitgewerkt voorbeeld

Neem de regel: kat, katoen, katheder, de kat slaapt. De opdracht is het dier door hond te vervangen. Tel eerst: de regel.match(/kat/g).length is 4. Je verwachtte 2. Dat ene getal, gelezen voordat er iets is geschreven, is de hele beveiliging — en had je vervangen in plaats van geteld, dan was de uitvoer „hond, hondoen, hondheder, de hond slaapt” geweest.

Anker en tel opnieuw: /\bkat\b/g vindt 2, en dat is het getal dat je verwachtte, en pas dan is vervangen veilig. Het resultaat is „hond, katoen, katheder, de hond slaapt”. Tel daarna nog een keer: /\bkat\b/g moet nu 0 vinden en /\bhond\b/g moet 2 vinden. Drie tellingen en één vervanging, vier regels in totaal, en elk ervan is een regel die je iemand kunt laten zien als hij vraagt wat de wijziging heeft gedaan.

Eén detail uit de Duitse versie van dezelfde oefening is het bewaren waard. Bahn door Zug vervangen op „Bahn, Bahnhof, Autobahn, die Bahn fährt” zonder ankers geeft 3 matches en niet 4: het patroon let op hoofdletters, dus raakt het Bahnhof maar mist het de kleine letters bahn binnen Autobahn. Een aantal dat lager is dan verwacht, is net zo informatief als een dat hoger is, en het wijst naar een andere fout.

Wat elk token in een vervangingstekenreeks betekent, uitgevoerd op „Totaal: 42 EUR” met het patroon /(\d+) (USD|EUR)/. De $ van een vervanging heeft niets te maken met de $ van een patroon: hier betekent hij nooit einde-van-tekenreeks.
TokenWat het invoegtVervanging zoals geschrevenResultaat
$&De hele match[$&]Totaal: [42 EUR]
$1Capturegroep 1$1Totaal: 42
$$Eén letterlijk dollarteken$$$1Totaal: $42
$10Groep 10 als die bestaat, anders groep 1 en dan het teken 0$10Totaal: 420
$` en $'Alles ervoor, alles na de match<$`>Totaal: <Totaal: >
$<naam>Een benoemde groep; blijft letterlijk als het patroon er geen heeft[$<amount>]Totaal: [42]
Tekst zoeken en vervangenVervang elk voorkomen van een woord of zin in je tekst in één keer.Probeer de tool →
Advertentie

Veelgestelde vragen

Waarom heeft mijn vervanging een hele regel gewist?
Bijna altijd een gulzige quantor tussen twee scheidingstekens die meer dan één keer voorkomen. /<.+>/ op een regel met twee tags matcht van de eerste < tot de laatste >, dus is de enige match de hele regel. Voeg een vraagteken toe om de quantor lui te maken, /<.+?>/, of beter: verbied het sluitende scheidingsteken binnen de match met een ontkende klasse, /<[^>]+>/.
Waarom geeft dezelfde regex een ander antwoord als ik hem een tweede keer aanroep?
Omdat hij de vlag g heeft en een lastIndex die tussen aanroepen blijft bestaan. /a/g vier keer getest tegen „banana” geeft waar, waar, waar, onwaar. Laat de vlag g weg als je alleen een ja-of-nee-antwoord wil, gebruik matchAll als je elk voorkomen wil, of zet re.lastIndex = 0 vóór elke zoektocht als het object echt gedeeld moet worden.
Hoe zet ik een letterlijk dollarteken in de vervanging?
Schrijf $$. Eén losse $ werkt alleen als er niets bijzonders op volgt, en dat maakt hem een fout die op de volgende bewerking wacht: „$$$1” op „Totaal: 42 EUR” geeft „Totaal: $42”, terwijl het intuïtieve „$$&” het letterlijke „$&” geeft in plaats van de match. Is de vervangingstekst data — een waarde uit een formulier, een vertaling, iets dat je niet zelf hebt getypt — geef dan een functie door in plaats van een tekenreeks, want de retourwaarde van een functie wordt ingevoegd zonder enige verwerking van $.
Begrijpt de vlag i accenten en andere alfabetten?
Hij begrijpt case folding en niets anders. Hij stelt a en A over het grootste deel van Unicode gelijk, maar hij normaliseert niet, dus faalt /é/i op een gedecomponeerde É; hij klapt niet uit, dus faalt /ss/i op ß; en hij kent geen enkele locale, dus faalt /i/i op de Turkse İ. Heb je een van die drie nodig, normaliseer dan eerst de tekst en gebruik een collator met sensitivity "base" om te vergelijken, in plaats van te verwachten dat de vlag talenkennis krijgt die hij nooit heeft gehad.
Hoe matcht ik over twee regels?
Voeg de vlag s toe, die de punt ook regeleindetekens laat matchen: /Price.*units/ is onwaar over twee regels en /Price.*units/s is waar. Verwar hem niet met m, die over ankers gaat en niet over de punt: m laat ^ en $ matchen bij het begin en het eind van elke regel in plaats van van de hele invoer, en laat de punt precies zoals hij was. Je wil ze vaak beide, en ze zijn onafhankelijk.
Waarom faalt \b op een woord dat op een letter met een accent eindigt?
Omdat \b is gedefinieerd tegen de ASCII-woordklasse [A-Za-z0-9_], en een letter met een accent zit daar niet in. Een grens heeft aan precies één kant een woordteken nodig, dus tussen é en een volgende spatie is er geen, en matcht /\bcafé\b/ „un café noir” niet — terwijl hij „un cafés” wél matcht, waar é door een ASCII-s wordt gevolgd. Vervang de asserties door Unicode-lookarounds: /(?<![\p{L}\p{N}])café(?![\p{L}\p{N}])/u, en onthoud dat \p{…} de vlag u nodig heeft.

Artikelen die je misschien interesseren

Alle gidsen →
HandleidingFiltering Lines by a Pattern Without a Command LineThis is grep for people who do not use grep, with one important difference: the match is a plain substring, so a real regular expression returns an empty box and no error. Every claim here was checked by running the tool.HandleidingRegex Basics: A Beginner's GuideA regular expression is a pattern for matching text. Here are the building blocks — character classes, quantifiers and anchors — with a worked example.HandleidingNumbering the Lines of a Text for a Review with Several PeopleNumbering starts at 1 and cannot be set to 0, the alignment is spaces rather than zeros, and the remover undoes eight of the eleven separators without touching the indentation. What it still cannot do is tell your numbers from its own.GidsFormatting Numbers for Six Languages: Separators, Currency and the Parse Back1,234.56 and 1.234,56 are the same number, and confusing them changes the value a reader parses. We ran Intl.NumberFormat for all six site locales and printed every separator — including the invisible one French uses — then measured why parseFloat cannot undo any of it.UitlegEmoji Are Harder Than They Look: Why "Just Strip the Emoji" Has No One-Line AnswerOne visible emoji can be one code point or fourteen UTF-16 units. We ran three popular regexes against a real sentence and each broke differently — one deleted the digits. Here is why, which Unicode property answers which question, and the grapheme-cluster rule that actually works.UitlegWhere a Line May Break: The Unicode Algorithm Behind Every Wrapped Paragraph"Break at spaces" fails in most of the world's writing systems. UAX #14 gives every character a line-break class; we looked ours up in Unicode 17.0.0 and ran a conforming implementation over no-break spaces, soft hyphens, zero-width spaces, URLs, Japanese and Thai.

Vergelijkbare tools

Bronnen

Een fout in dit artikel gezien?