Regular Expressions — Cheatsheet

Johan Beysen

Wat zijn Regular Expressions?

Een regular expression (regex) is een patroon dat beschrijft wat een string mag bevatten. Je gebruikt het om tekst te zoeken, valideren of vervangen.

/^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/i

Dat patroon matcht een e-mailadres. Elk teken heeft een betekenis — dit document legt ze uit.

Testen

Gebruik regex101.com om patronen interactief te testen met uitleg per token.

Anchors

Anchors matchen een positie, geen teken.

Patroon	Betekenis	Voorbeeld match
`^`	Begin van de string	`^hallo` matcht `hallo wereld`
`$`	Einde van de string	`wereld$` matcht `hallo wereld`
`\b`	Woordgrens	`\bcat\b` matcht `cat` maar niet `catch`
`\B`	Geen woordgrens	`\Bcat\B` matcht `concatenate`

Character Classes

Patroon	Betekenis
`.`	Elk teken behalve newline
`\d`	Cijfer — `[0-9]`
`\D`	Geen cijfer — `[^0-9]`
`\w`	Woordteken — `[a-zA-Z0-9_]`
`\W`	Geen woordteken
`\s`	Whitespace — spatie, tab, newline
`\S`	Geen whitespace
`\n`	Newline
`\t`	Tab

Eigen klassen met `[ ]`

[aeiou]       — één van de tekens a, e, i, o, u
[a-z]         — kleine letter a tot z
[A-Z]         — hoofdletter A tot Z
[0-9]         — cijfer 0 tot 9
[a-zA-Z0-9]   — letter of cijfer
[^aeiou]      — alles behalve een klinker  (^ = negatie binnen [ ])
[a-z&&[^aeiou]] — consonant (Java-syntax)

Quantifiers

Quantifiers bepalen hoe vaak het vorige element mag voorkomen.

Patroon	Betekenis	Greedy?
`*`	0 of meer keer	Ja
`+`	1 of meer keer	Ja
`?`	0 of 1 keer (optioneel)	Ja
`{n}`	Exact n keer	Ja
`{n,}`	Minstens n keer	Ja
`{n,m}`	Tussen n en m keer	Ja
`*?`	0 of meer — lazy	Nee
`+?`	1 of meer — lazy	Nee
`??`	0 of 1 — lazy	Nee

Greedy vs Lazy

Greedy (standaard): pakt zo veel mogelijk tekens.
Lazy (met ?): pakt zo weinig mogelijk tekens.

Input:   <b>vet</b> en <i>schuin</i>
<.+>     matcht:  <b>vet</b> en <i>schuin</i>   ← greedy, alles
<.+?>    matcht:  <b>   en daarna   <i>          ← lazy, elk tag apart

Groepen & Referenties

Patroon	Betekenis
`(abc)`	Capture group — onthoudt de match
`(?:abc)`	Non-capturing group — groepeert zonder op te slaan
`(?P<naam>abc)`	Named capture group (Python/PCRE)
`(?<naam>abc)`	Named capture group (JS/.NET)
`\1`	Backreference naar groep 1
`\k<naam>`	Backreference naar named group
`a\\|b`	Alternatie — a of b

(https?):\/\/   — capture group 1 = "http" of "https"
(?:https?):\/\/ — zelfde match, maar niet opgeslagen
(\w+)\s\1       — matcht een herhaald woord: "hello hello"

Lookahead & Lookbehind

Matchen op basis van wat voor of na de positie staat — zonder die context op te nemen in de match.

Patroon	Type	Betekenis
`(?=abc)`	Positive lookahead	gevolgd door `abc`
`(?!abc)`	Negative lookahead	niet gevolgd door `abc`
`(?<=abc)`	Positive lookbehind	voorafgegaan door `abc`
`(?<!abc)`	Negative lookbehind	niet voorafgegaan door `abc`

\d+(?= euro)      — matcht getal alleen als er " euro" achter staat
\d+(?! euro)      — matcht getal als er GEEN " euro" achter staat
(?<=€)\d+         — matcht getal alleen als er "€" voor staat
(?<!€)\d+         — matcht getal als er GEEN "€" voor staat

Flags / Modifiers

Flags wijzigen het gedrag van de hele regex.

Flag	Betekenis
`i`	Case-insensitive
`g`	Global — alle matches, niet enkel de eerste
`m`	Multiline — `^` en `$` matchen per lijn
`s`	Dotall — `.` matcht ook newlines
`x`	Extended — whitespace en comments toegestaan

JavaScriptPythongrep

/patroon/flags
/hello/gi         // global + case-insensitive

import re
re.findall(r'patroon', tekst, re.IGNORECASE | re.MULTILINE)
re.IGNORECASE  # i
re.MULTILINE   # m
re.DOTALL      # s
re.VERBOSE     # x

grep -i   # case-insensitive
grep -E   # extended regex (ERE) — +, ?, |, () zonder backslash
grep -P   # Perl-compatible regex (PCRE)
grep -o   # toon enkel de gematchte tekst

Speciale Tekens Escapen

Deze tekens hebben een speciale betekenis en moeten ge-escaped worden met \ als je ze letterlijk bedoelt:

. * + ? ^ $ { } [ ] | ( ) \

3\.14        — matcht letterlijk "3.14" (niet "3X14")
\(groep\)    — matcht letterlijk "(groep)"
C\+\+        — matcht letterlijk "C++"

Veelgebruikte Patronen

Validatie

E-mail:         ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
IPv4:           ^(\d{1,3}\.){3}\d{1,3}$
IPv6 (simpel):  ^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$
URL:            https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b
Datum (ISO):    ^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$
Tijd (HH:MM):   ^([01]\d|2[0-3]):[0-5]\d$
Postcode (BE):  ^[1-9]\d{3}$
IBAN (BE):      ^BE\d{2}\d{12}$
BTW (BE):       ^BE0\d{9}$

Wachtwoordsterkte

Minstens 8 tekens:                        ^.{8,}$
Minstens 1 hoofdletter:                   ^(?=.*[A-Z])
Minstens 1 kleine letter:                 ^(?=.*[a-z])
Minstens 1 cijfer:                        ^(?=.*\d)
Minstens 1 speciaal teken:                ^(?=.*[!@#$%^&*])
Alles samen (8+, upper, lower, cijfer):   ^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$

Tekst manipulatie

Witruimte trimmen (begin/einde):  ^\s+|\s+$
Meerdere spaties samenvoegen:     \s{2,}
Lege regels verwijderen:          ^$\n
HTML-tags verwijderen:            <[^>]+>
Kommentaar (// ...):              \/\/.*$
Kommentaar (/* ... */):           \/\*[\s\S]*?\*\/

Netwerk & Security

MAC-adres:                ([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}
Private IP (RFC 1918):    ^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)
Base64:                   ^[A-Za-z0-9+/]+={0,2}$
JWT (3 delen):            ^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$
Hash MD5:                 ^[a-f0-9]{32}$
Hash SHA1:                ^[a-f0-9]{40}$
Hash SHA256:              ^[a-f0-9]{64}$

Tool-specifieke Syntax

grep / egrep

grep  'patroon' bestand          # BRE — basic regex
grep -E 'patroon' bestand        # ERE — extended (+ ? | () zonder \)
grep -P 'patroon' bestand        # PCRE — Perl-compatible
grep -o '\b[A-Z]{2,}\b' bestand  # toon enkel de match
grep -n 'patroon' bestand        # toon regelnummers
grep -r 'patroon' map/           # recursief
grep -v 'patroon' bestand        # regels ZONDER match

sed

sed 's/oud/nieuw/'        # vervang eerste match per lijn
sed 's/oud/nieuw/g'       # vervang alle matches
sed 's/oud/nieuw/gi'      # case-insensitive + global
sed -n '/patroon/p'       # toon enkel matchende regels
sed '/patroon/d'          # verwijder matchende regels
sed 's/\(groep\)/[\1]/'   # backreference in BRE
sed -E 's/(groep)/[\1]/'  # backreference in ERE

Python

import re

re.match(r'patroon', tekst)          # match enkel aan het begin
re.search(r'patroon', tekst)         # match overal
re.findall(r'patroon', tekst)        # lijst van alle matches
re.sub(r'oud', 'nieuw', tekst)       # vervangen
re.split(r'\s+', tekst)              # splitsen

m = re.search(r'(\d+)-(\d+)', tekst)
m.group(0)   # volledige match
m.group(1)   # eerste groep
m.groups()   # tuple van alle groepen

JavaScript

const re = /patroon/flags;

'tekst'.match(/patroon/g)              // alle matches
'tekst'.replace(/oud/g, 'nieuw')       // vervangen
'tekst'.split(/\s+/)                   // splitsen
/patroon/.test('tekst')                // true/false

const m = 'tekst'.match(/(\w+)/);
m[0]   // volledige match
m[1]   // eerste groep

BRE vs ERE vs PCRE

Functie	BRE (`grep`)	ERE (`grep -E`)	PCRE (`grep -P`)
Groepen	``	`()`	`()`
Alternatie	`\\|`	`\\|`	`\\|`
`+` quantifier	`\+`	`+`	`+`
`?` quantifier	`\?`	`?`	`?`
Lookahead	✗	✗	`(?=...)`
Lookbehind	✗	✗	`(?<=...)`
Named groups	✗	✗	`(?P<naam>...)`
`\d \w \s`	✗	✗	✓

Functie	BRE (`grep`)	ERE (`grep -E`)	PCRE (`grep -P`)
Groepen	`\(\)`	`()`	`()`
Alternatie	`\\|`	`\\|`	`\\|`
`+` quantifier	`\+`	`+`	`+`
`?` quantifier	`\?`	`?`	`?`
Lookahead	✗	✗	`(?=...)`
Lookbehind	✗	✗	`(?<=...)`
Named groups	✗	✗	`(?P<naam>...)`
`\d \w \s`	✗	✗	✓