Regex Builder: test reguliere expressies visueel (met een spiekbriefje)

Ik heb een bekentenis die regex puristen zal doen huiveren: voor de eerste paar jaar van mijn carrière, schreef ik regelmatige uitdrukkingen door te kopiëren-plakken van Stack Overflow, het veranderen van een personage, het uitvoeren van de code, het zien falen, en herhalen tot het toevallig werkte Ik deed 't begrijp de patronen - ik pestte ze tot onderwerping Het was traag, en erger nog, de patronen die ik verscheepte waren kwetsbaar op manieren die ik kon ' niet zien.

Wat dat verhelpt was ' t het lezen van de theorie (hoewel ik uiteindelijk deed) Het was een visuele tester - een doos waar ik het patroon typ, een doos waar ik teststrings plak, en matches die oplichten zodra ik iets zou veranderen Plotseling kon ik bestrijken waarom \d+ Ging meer dan ik wilde, of waarom mijn e-mailpatroon een volkomen geldig adres afwees. Regex stopte met een raadspel en werd een strakke feedbacklus.

Dat is precies wat de Regex-bouwer op Toolz.dev is U schrijft een patroon, laat testgegevens vallen, schakelt vlaggen en bekijk de wedstrijden en vastgelegde groepen markeren in realtime Het draait volledig in uw browser, dus de logregels of gebruikersgegevens u 're testen tegen nooit ergens geüpload Deze gids is de regex referentie Ik wou dat I'd had toen - de patronen die ik daadwerkelijk hergebruik, een volledige cheat sheet, en de enige fout die een productieserver kan uitschakelen.

tl;dr: Plak je patroon en test strings in de Regex-bouwer en schakel de g/i/m Vlaggen om wedstrijden te zien markeren live. Begin eenvoudig, voeg beperkingen toe om valse positieven te doden en test adversarial inputs om catastrofale backtracking te voorkomen. Voor uitgepakte gegevens koppelt u deze met de JSON-formatter en Base64-converter. Alle client-side, allemaal gratis.

Wat is precies een reguliere expressie?

Een reguliere expressie - regex of regexp - is een compacte string die een zoekpatroon beschrijft In plaats van " zoek het woord cat, & quot; kunt u zeggen & quot; zoek een willekeurig getal van vijf cijfers, & quot; & quot; zoek alles wat op een e-mail lijkt, & quot; of & quot; zoek elke regel die begint met ERROR." Bijna elke taal en editor ondersteunt ze, wat de vaardigheid zo draagbaar maakt: leer het één keer en je gebruikt het in JavaScript, Python, je grep, en uw IDE's vinden en vervangen.

Het concept komt uit de formele taaltheorie uit de jaren vijftig, en Ken Thompson verbond het in de jaren zestig voor computerbewerking voor tekstbewerking. Die geschiedenis is van belang om één praktische reden waarom ik terugkom bij: "gewone" talen hebben limieten, daarom kan Regex echt geen geneste structuren zoals HTML ontleden, hoe slim je ook bent.

Waar ik in een normale week naar regex reik: het valideren van gebruikersinvoer voordat deze de database bereikt, velden uit ongestructureerde loglijnen halen, zoeken en vervangen over een hele codebase die een eenvoudige zoekopdracht niet kan uitdrukken, en gegevens filteren tijdens een migratie. de Regex-bouwer is waar ik allemaal prototypes heb voordat het in de buurt van echte code komt.

Hier zijn de fundamentele bouwstenen - het alfabet waaruit je patronen samenstelt

Welke regex-patronen moet elke ontwikkelaar bij de hand houden?

Dit zijn degenen die ik heb getest, kapot, gerepareerd en nu in een persoonlijk fragmentbestand bewaard. kopieer ze direct in de Regex-bouwer En gooi je eigen randkoffers naar hen.

E-mail (de praktische soort)

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Deze komt overeen [email protected] en [email protected], en verwerpt @example.com of user@com. Hier is de belangrijke eerlijkheid echter: de volledige e-mailgrammatica in RFC 5322 is monsterlijk complex - het staat technisch gezien geciteerde tekenreeksen en opmerkingen toe die bijna niemand gebruikt Don' t jaag 100% RFC-naleving na met een regex. Match de praktische 99% met het bovenstaande patroon en bevestig vervolgens dat het adres echt is door een verificatie-e-mail te sturen. Dat en#39; is de fout die ik het meest zie: teams branden dagen op een & quot;airtight" e-mail regex die nog steeds kan't vertel een echte inbox aan een typefout.

url

^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$

wedstrijd https://toolz.dev en http://www.example.com/path?query=value; verwerpt ftp://... en platte tekst.

ons telefoonnummer

^(\+1)?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$

flexibel genoeg voor 555-123-4567, (555) 123-4567, +1 555.123.4567, en 5551234567.

IPv4-adres

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

De geneste afwisseling is wat afdwingt dat elk octet in 0-255 blijft, dus het verwerpt correct 999.999.999.999.

Sterke wachtwoordcontrole

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

Vereist minimaal 8 tekens met een kleine letter, een hoofdletter, een cijfer en een symbool. de (?=...) lookaheads beweren elk één voorwaarde zonder karakters te consumeren - een leuke truc die het begrijpen waard is.

ISO-datum (JJJJ-MM-DD)

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

wedstrijd 2026-07-11, verwerpt 2026-13-01 en 2026-02-32.

hex kleur

^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$

wedstrijd #4466EE, #abc, #000000.

het regex-sprekersblad

Houd dit vast. Het is de referentie die ik het meest controleer.

ankers

quantificatoren

Karakterklassen

Groepen en kijkjes

vlagen

Hoe bouw en debug je een patroon zonder een uur te verliezen?

Mijn proces is expres saai, omdat saai herhaalbaar is:

1. Begin met het eenvoudigste dat overeenkomt met één echt voorbeeld. Probeer niet elke zaak tegelijk af te handelen.
2. Plak zowel positieve als negatieve teststrings in de Regex-bouwer- dingen die moeten overeenkomen en dingen die dat niet mogen.
3. Draai aan om valse positieven te doden. ankers toevoegen (^, $) Dus het patroon komt overeen met de hele string en swap . Voor specifieke klassen zoals [a-z] of [^,].
4. gooi er tegenstanders in input- lege tekenreeksen, enorme invoer, Unicode en letterlijke regextekens als gegevens.
5. Pas dan alleen optimaliseren.

Als iets zich misdraagt, is het bijna altijd een van de drie dingen. als het Komt te veel overeen, je kwantoren zijn hebzuchtig - maak ze lui (*?) of uw lessen specifieker. als het Komt te weinig overeen, je hebt waarschijnlijk de i vlag of vergat te ontsnappen aan een speciaal personage. als het Komt helemaal niets overeen, controleer op niet-ontsnapte metakarakters (., *, +, (, [, {, enz.) bedoeld als letterlijke of onzichtbare tekens zoals tabbladen die zich in uw testreeks verbergen.

Wat is catastrofale backtracking en waarom zou je er bang voor zijn?

Dit is het gedeelte dat ik zou tatoeëren op nieuwe ontwikkelaars als ik kon. Al vroeg verzendde ik een input-validation regex die er volkomen onschuldig uitzag, en op een middag koppelde een enkel verzoek een CPU-kern aan 100% en bleef daar. Het patroon was het probleem.

Wanneer een Regex-engine geen match kan vinden, is het terugsporen- het trekt zich terug en probeert andere manieren om aan het patroon te voldoen Bepaalde vormen laten het aantal paden exponentieel exploderen Het schoolvoorbeeld:

^(a+)+$

voer dat een invoer zoals aaaaaaaaaaaaaaaaaaaab (een run van a eindigend in een b), en de geneste quantificators geven de motor een astronomisch aantal manieren om de as, die het allemaal probeert voordat het afrondt "geen match." Uw app loopt vast. Dit is een echte denial-of-service-klasse genaamd opnieuw (Regular Expression Denial of Service) en aanvallers maken er gebruik van.

Hoe veilig te blijven:

1. Nooit kwantificatoren nest. (a+)+, (a*)*, en (a+)* zijn rode vlaggen.
2. Gebruik atomaire groepen of bezittelijke kwantoren Waar de motor hen ondersteunt: (?>a+) of a++.
3. Wees specifiek. [a-z]+ minder dan terug .+ Omdat het minder paden te verkennen.
4. Veranker je patronen Dus de motor faalt snel op niet-overeenkomende ingang.
5. Test met snaren die bijna overeenkomen maar mislukken helemaal aan het einde- dat' is het ergste geval voor backtracking.

Als je onderweg bent, bestaat dit probleem gewoon niet, wat me bij de volgende sectie brengt.

Hoe verschilt regex tussen talen?

De kernsyntaxis reist goed, maar de details bijten. Dit zijn de verschillen waar ik echt over struikelde.

JavaScript:

const regex = /\d{3}-\d{4}/g;
const pattern = new RegExp('\\d{3}-\\d{4}', 'g'); // note the doubled backslashes
'555-1234'.match(regex);              // ["555-1234"]
const m = '2026-07-11'.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
m.groups.year;                        // "2026"

Pas op: lookbehind kwam pas in ES2018 aan, \d komt alleen overeen met ASCII-cijfers en de g vlag maakt .test() Afgevaardigd via lastIndex- een subtiele bugbron in loops.

Python:

import re
pattern = re.compile(r'\d{3}-\d{4}')      # raw strings avoid double-escaping
pattern.findall('Call 555-1234 or 555-5678')  # ['555-1234', '555-5678']

Gebruik altijd rauwe strings (r'...'). zich herinneren re.match alleen ankers bij de start - gebruik re.search ergens te vinden. en re.VERBOSE Hiermee kunt u patronen met meerdere regels schrijven, wat een redder in nood is voor complexe.

php: Patronen hebben scheidingstekens nodig ('/\d{3}-\d{4}/'), het maakt gebruik van de krachtige PCRE-engine en preg_match opbrengst 1, 0, of false op fout - dus check met ===.

gaan: Gebruikt de RE2-motor, die bewust Drops lookaheads, lookbehinds en backreferenties in ruil voor een garantie voor lineaire-tijdmatching Dat betekent dat er zelfs geen catastrofale backtracking mogelijk is - een echt andere afweging die de moeite waard is om te weten wanneer je een taal kiest voor matching zonder vertrouwde invoer.

Een echt voorbeeld: het ontleden van een Apache-loglijn

Hier is het soort ding dat Regex echt geweldig is. Een standaard Apache Access Log-regel ziet eruit als:

192.168.1.1 - frank [11/Jul/2026:10:27:10 -0500] "GET /api/users HTTP/1.1" 200 1234

Dit patroon trekt het uit elkaar:

^(\S+) \S+ (\S+) \[([^\]]+)\] "(\S+) (\S+) (\S+)" (\d{3}) (\d+)$

Plak beide in de Regex-bouwer En elke vastgelegde groep licht afzonderlijk op:

Zodra de groepen in de tester staan, vertaalt u deze naar een re.findall in python of a match() in JavaScript is triviaal - en je weet al dat het werkt.

Veelgestelde vragen

Wat is een regex-bouwer?

Een Regex Builder is een interactieve tool waarbij je een reguliere expressie typt en deze meteen ziet vergeleken met teststrings, waarbij overeenkomsten en vastgelegde groepen zijn gemarkeerd. Het vervangt de langzame schrijf-run-fail-rewrite-lus in uw code door een live-lijn. de Regex-bouwer Op Toolz.dev doet dit volledig in uw browser, zodat testgegevens op uw machine blijven.

Zijn regex-patronen identiek in elke programmeertaal?

De kernsyntaxis is bijna identiek, maar de details verschillen voldoende om bugs te veroorzaken. Ouder JavaScript miste lookbehind, GO's RE2-engine heeft helemaal geen lookaheads of backreferenties, en Python noemt groepen met (?P<name>...) in sommige contexten. Bevestig altijd een patroon in de taal waarop u zich daadwerkelijk richt in plaats van de draagbaarheid te veronderstellen.

Hoe valideer ik een e-mailadres met regex?

Gebruik een praktisch patroon zoals ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$, die de overgrote meerderheid van echte adressen behandelt Probeer niet volledige RFC 5322-compliance in een regex - de grammatica is veel te complex en u & # 39; zal nog steeds geldige adressen weigeren of typefouten accepteren Koppel de regex met een verificatie-e-mail om te bevestigen dat de inbox daadwerkelijk bestaat.

Waarom bevriest mijn regex de applicatie?

Bijna altijd catastrofale terugslag. Patronen met geneste quantificators zoals (a+)+ Creëer een exponentieel aantal overeenkomende paden wanneer ze input ontmoeten die bijna overeenkomt maar uiteindelijk faalt, en de motor probeert ze allemaal. verwijder geneste kwantoren, geef de voorkeur aan specifieke karakterklassen boven .+en voeg ankers toe zodat de motor snel kan uitvallen.

Kan ik regex gebruiken om HTML of JSON te ontleden?

Nee, niet voor iets dat verder gaat dan triviale extractie HTML en JSON zijn geen reguliere talen - ze staan willekeurige nesting toe die regex fundamenteel niet kan volgen Gebruik een echte parser: DOMParser of Cheerio voor HTML, en JSON.parse of een JSON-tool voor JSON. Regex is het verkeerde hulpmiddel, de momentstructuur nestelt.

Wat is het verschil tussen hebzuchtig en lui matchen?

hebzuchtige quantificators (*, +, ?) zoveel mogelijk pakken en zo nodig teruglopen; luie (*?, +?, ??) Pak zo min mogelijk en breid alleen uit als je geforceerd bent. met <b>bold</b>, hebzuchtig <.*> slikt het hele touw door terwijl lui <.*?> stopt bij de eerste <b>. Het kiezen van de juiste is vaak de oplossing wanneer een patroon te veel overeenkomt.

Hoe ontsnap ik aan speciale tekens in regex?

Zet een backslash voor elk metakarakter dat je letterlijk bedoelt: \., \*, \+, \?, \(, \), \[, \], \{, \}, \^, \$, \|, en \\. De meeste talen bieden ook een helper om aan een hele string voor je te ontsnappen - re.escape() in Python bijvoorbeeld - wat veiliger is dan met de hand ontsnappen als de string afkomstig is van gebruikersinvoer.

Wat betekenen de Regex vlaggen G, I en M?

g (global) vindt elke wedstrijd in plaats van te stoppen bij de eerste, i (geval negeren) maakt het patroon hoofdletterongevoelig, en m (Multiline) maakt ^ en $ Match bij elke regeleinde in plaats van alleen de begin en einde van de string. Ze combineren vrijelijk, dus gim doet alle drie. Een frequente gotcha in JavaScript: hergebruik van een g Regex voor alle oproepen lastIndex tussen hen, waardoor test() wissel waar en onwaar af - maak het patroon opnieuw of reset lastIndex.

Wat is een blik in regex?

Een bliksem beweert dat iets wel of niet volgt, zonder het te consumeren. foo(?=bar) wedstrijd foo pas wanneer bar komt daarna; foo(?!bar) Past alleen als het niet lukt. kijk achter ((?<=...), (?<!...)) doet hetzelfde achteruit, en is geland in modern JavaScript, Python en PCRE - maar niet in Go' s RE2, die beide regelrecht afwijst Wachtwoordregels zijn het klassieke gebruik: ^(?=.*\d)(?=.*[a-z]).{8,}$ Stapelt beweringen zodat elke eis onafhankelijk wordt gecontroleerd op dezelfde positie.

Hoe verbind ik een telefoonnummer met regex?

Wees voor een specifiek formaat expliciet in plaats van slim: ^\(\d{3}\) \d{3}-\d{4}$ wedstrijd (555) 123-4567. Om gevarieerde scheiders te tolereren, laat u optionele scheidingstekens toe zoals: ^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$. Telefoonnummering is rommelig in alle landen, dus valideer alleen het formaat dat u daadwerkelijk accepteert en normaliseer naar cijfers voordat u het patroon live opslaat - bouw en test voordat u het vertrouwt.

inpakken

Regex ging van mijn meest gevreesde vaardigheid naar een van mijn meest gebruikte op het moment dat ik begon met het bouwen van patronen in een live tester in plaats van te raden in mijn editor. Begin eenvoudig, test tegen echte en adversarial input, respecteer catastrofale terugslag en houd een persoonlijke bibliotheek met patronen bij die u vertrouwt.

de Regex-bouwer op Toolz.dev maakt die lus snel, met real-time matching, groepsverhoging en vlagschakelaars - allemaal actief in uw browser zodat uw testgegevens privé blijven Wanneer uw patroon JSON extraheert, geeft u deze door aan de JSON-formatter; wanneer het een base64-blob vastlegt, decodeer deze met de Base64-converter. Of blader door alle 600+ gratis tools op Toolz.dev.