Snelle referentietabel voor reguliere expressie syntaxis

Reguliere expressies, ook wel regex genoemd, zijn tekstenpatronen die vaak worden gebruikt om tekst te doorzoeken, te vervangen en te controleren. Ze bevatten voornamelijk de letters a tot z en enkele speciale metakarakters. De toepassing van reguliere expressies is zeer breed; het werd oorspronkelijk populair gemaakt door Unix en is daarna wijdverbreid toegepast in Scala, PHP, C#, Java, C++, Objective-C, Perl, Swift, VBScript, Javascript, Ruby en Python. Het leren van reguliere expressies is in feite het leren van een zeer flexibele manier van logisch denken, waarmee je op een snelle en eenvoudige manier controle krijgt over strings.

RegEx Karakter	Beschrijving
\	Merk het volgende karakter aan als een speciaal karakter, een letterlijk karakter, een terugverwijzing, of een octale escape. Bijvoorbeeld, “`n`” matcht het karakter "`n`". "`\n`" matcht een nieuwe regel. Het string "`\\`" matcht "`\`" en "`\(`" matcht "`(`".
^	Matcht de beginpositie van de invoerstring. Als de Multiline eigenschap van het RegExp object is ingesteld, matcht ^ ook de positie na "`\n`" of "`\r`".
$	Matcht de eindpositie van de invoerstring. Als de Multiline eigenschap van het RegExp object is ingesteld, matcht $ ook de positie voor "`\n`" of "`\r`".
*	Matcht de voorgaande subexpressie nul of meer keren. Bijvoorbeeld, zo* kan matchen met "`z`" en "`zoo`". * is gelijk aan {0,}.
+	Matcht de voorgaande subexpressie één of meer keren. Bijvoorbeeld, "`zo+`" kan matchen met "`zo`" en "`zoo`", maar niet met "`z`". + is gelijk aan {1,}.
?	Matcht de voorgaande subexpressie nul of één keer. Bijvoorbeeld, "`do(es)?`" kan matchen met "`does`" of "`do`" in "`does`". ? is gelijk aan {0,1}.
{n}	n is een niet-negatief geheel getal. Matcht precies n keren. Bijvoorbeeld, "`o{2}`" kan niet matchen met "`Bob`" voor het "`o`", maar kan matchen met de twee "o" in "`food`".
{n,}	n is een niet-negatief geheel getal. Matcht ten minste n keren. Bijvoorbeeld, "`o{2,}`" kan niet matchen met "`Bob`" voor het "`o`", maar matcht allemaal "o" in "`foooood`". "`o{1,}`" is gelijk aan "`o+`". "`o{0,}`" is gelijk aan "`o*`".
{n,m}	m en n zijn beide niet-negatieve gehele getallen, waarbij n <= m. Matcht ten minste n keren en maximaal m keren. Bijvoorbeeld, "`o{1,3}`" matcht de eerste drie "o" in "`fooooood`". "`o{0,1}`" is gelijk aan "`o?`". Let op: er mogen geen spaties staan tussen de komma en de twee nummers.
?	Wanneer dit karakter direct volgt na enig ander kwantificeerder (*, +, ?, {n}, {n,}, {n,m}), is de matchingmodus non-greedy. De non-greedy modus matcht zo min mogelijk van de zoekstring, terwijl de standaard greedy modus zoveel mogelijk matcht. Bijvoorbeeld, voor de string "`oooo`", "`o+?`" matcht een enkele "`o`", terwijl "`o+`" alle "`o`" matcht.
.	Matcht elk enkel karakter, behalve "`\n`". Om elk karakter, inclusief "`\n`" te matchen, gebruik een patroon als "`(.\|\n)`".
(pattern)	Matcht pattern en verkrijgt deze match. De verkregen match kan uit de geproduceerde Matches collectie worden gehaald, in VBScript met de SubMatches collectie en in JScript met de $0…$9 eigenschappen. Om de haakjes te matchen, gebruik "`$`" of "`$`".
(?:pattern)	Matcht pattern maar verkrijgt de match niet, dat wil zeggen het is een non-capturing match, en wordt niet opgeslagen voor later gebruik. Dit is handig bij het gebruiken van de alternatie "`(\|)`" om verschillende delen van een patroon te combineren. Bijvoorbeeld: "`industr(?:y\|ies)`" is een beknoptere uitdrukking dan "`industry\|industries`".
(?=pattern)	Positieve lookahead, matcht de zoekstring die begint met een string die pattern matcht. Dit is een non-capturing match, dat wil zeggen, deze match hoeft niet te worden opgeslagen voor later gebruik. Bijvoorbeeld, "`Windows(?=95\|98\|NT\|2000)`" kan matchen met "`Windows2000`" maar niet met "`Windows3.1`". De lookahead consumeert geen tekens, dat wil zeggen, na een match begint de volgende zoekmatch meteen na de laatste match in plaats van te beginnen na het karakter dat de lookahead bevat.
(?!pattern)	Negatieve lookahead, matcht de zoekstring die begint met een string die niet pattern matcht. Dit is een non-capturing match, dat wil zeggen, deze match hoeft niet te worden opgeslagen voor later gebruik. Bijvoorbeeld "`Windows(?!95\|98\|NT\|2000)`" kan matchen met "`Windows3.1`" maar niet met "`Windows2000`". De lookahead consumeert geen tekens, dat wil zeggen, na een match begint de volgende zoekmatch meteen na de laatste match in plaats van te beginnen na het karakter dat de lookahead bevat.
(?<=pattern)	Negatieve lookbehind, net als de positieve lookahead, maar de richting is omgekeerd. Bijvoorbeeld "`(?<=95\|98\|NT\|2000)Windows`" kan matchen met "`2000Windows`" maar niet met "`3.1Windows`".
(?<!pattern)	Negatieve lookbehind, net als de negatieve lookahead, maar de richting is omgekeerd. Bijvoorbeeld "`(?<!95\|98\|NT\|2000)Windows`" kan matchen met "`3.1Windows`" maar niet met "`2000Windows`".
x\|y	Matcht x of y. Bijvoorbeeld, "`z\|food`" kan "`z`" of "`food`" matchen. "`(z\|f)ood`" matcht "`zood`" of "`food`".
[xyz]	Karaktergroep. Matcht een willekeurig karakter dat erin is opgenomen. Bijvoorbeeld, "`[abc]`" kan "`a`" in "`plain`" matchen.
[^xyz]	Negatieve karaktergroep. Matcht een willekeurig karakter dat niet is opgenomen. Bijvoorbeeld, "`[^abc]`" kan "`p`" in "`plain`" matchen.
[a-z]	Karakterbereik. Matcht een willekeurig karakter binnen het opgegeven bereik. Bijvoorbeeld, "`[a-z]`" kan een willekeurige kleine letter van "`a`" tot "`z`" matchen.
[^a-z]	Negatief karakter bereik. Matcht een willekeurig karakter dat niet binnen het opgegeven bereik valt. Bijvoorbeeld, "`[^a-z]`" kan elk karakter matchen dat niet binnen het bereik van "`a`" tot "`z`" valt.
\b	Matcht een woordgrens, oftewel de positie tussen een woord en een spatie. Bijvoorbeeld, "`er\b`" kan "`never`" matchen voor "`er`", maar niet voor "`verb`".
\B	Matcht een niet-woordgrens. "`er\B`" kan "`verb`" matchen voor "`er`", maar niet voor "`never`".
\cx	Matcht de controlekarakter aangeduid door x. Bijvoorbeeld, \cM matcht een Control-M of carriage return. De waarde van x moet een van de A-Z of a-z zijn. Anders wordt c behandeld als een letterlijk "`c`" karakter.
\d	Matcht een cijfer karakter. Is gelijk aan [0-9].
\D	Matcht een niet-cijfer karakter. Is gelijk aan [^0-9].
\f	Matcht een pagina-einde karakter. Is gelijk aan \x0c en \cL.
\n	Matcht een nieuwe lijn karakter. Is gelijk aan \x0a en \cJ.
\r	Matcht een carriage return karakter. Is gelijk aan \x0d en \cM.
\s	Matcht elk witruimte karakter, inclusief spaties, tabs, en pagina-einde. Is gelijk aan [ \f\n\r\t\v].
\S	Matcht elk niet-witruimte karakter. Is gelijk aan [^ \f\n\r\t\v].
\t	Matcht een tab karakter. Is gelijk aan \x09 en \cI.
\v	Matcht een verticale tab. Is gelijk aan \x0b en \cK.
\w	Matcht elk woord karakter, inclusief onderstreep. Is gelijk aan "`[A-Za-z0-9_]`".
\W	Matcht elk niet-woord karakter. Is gelijk aan "`[^A-Za-z0-9_]`".
\xn	Matcht n, waarbij n een hexadecimale escape waarde is. Hexadecimale escape waarden moeten exact twee cijfers lang zijn. Bijvoorbeeld, "`\x41`" matcht "`A`". "`\x041`" is gelijk aan "`\x04&1`". Hexadecimale escapes kunnen gebruikt worden in reguliere expressies.
\num	Matcht num, waarbij num een positief geheel getal is. Voor verwijzingen naar de verkregen match. Bijvoorbeeld, "`(.)\1`" matcht twee opeenvolgende dezelfde karakters.
\n	Geeft een octale escape waarde of terugverwijzing aan. Als \n minstens \n verkregen subexpressies eerder heeft, dan is n een terugverwijzing. Anders, als n een octaal cijfer (0-7) is, dan is n een octale escape waarde.
\nm	Geeft een octale escape waarde of terugverwijzing aan. Als \nm minstens nm verkregen subexpressies eerder heeft, dan is nm een terugverwijzing. Als \nm minstens n verkregen heeft, dan is n een terugverwijzing gevolgd door het letterlijke m. Als geen van deze voorwaarden voldoet, en als n en m allebei octale cijfers zijn (0-7), dan matcht \nm de octale escape waarde nm.
\nml	Als n een octaal cijfer is (0-3), en zowel m als l zijn octale cijfers (0-7), matcht het de octale escape waarde nml.
\un	Matcht n, waarbij n een Unicode teken is dat wordt voorgesteld door vier hexadecimale cijfers. Bijvoorbeeld, \u00A9 matcht het copyright symbool (©).

Veelgebruikte RegEx

Gebruikersnaam	/^[a-z0-9_-]{3,16}$/
Wachtwoord	/^[a-z0-9_-]{6,18}$/
Wachtwoord2	(?=^.{8,}$)(?=.\d)(?=.\W+)(?=.[A-Z])(?=.[a-z])(?!.\n).$ (bestaat uit cijfers/hoofdletters/kleine letters/speciale tekens, allemaal vereist, minimaal 8 tekens)
Hexadecimale waarde	/^#?([a-f0-9]{6}\|[a-f0-9]{3})$/
E-mail	/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/ /^[a-z\d]+(\.[a-z\d]+)@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/ of \w+([-+.]\w+)@\w+([-.]\w+)\.\w+([-.]\w+)
URL	/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-])\/?$/ of [a-zA-z]+://[^\s]*
IP Adres	/((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)/ /^(?:(?: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]?)$/ of ((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)
HTML Tag	/^<([a-z]+)([^<]+)(?:>(.)<\/\1>\|\s+\/>)$/ of <(.)(.)>.<\/\1>\|<(.) \/>
Verwijder Code\\Commentaar	(?<!http:\|\S)//.*$
Match Dubbele Byte Karakters (inclusief Chinese Tekens)	[^\x00-\xff]
Chinese Tekens	[\u4e00-\u9fa5]
Unicode Codering Chinese Tekens Bereik	/^[\u2E80-\u9FFF]+$/
Chinese en Volledige Interpunctie Tekens	[\u3000-\u301e\ufe10-\ufe19\ufe30-\ufe44\ufe50-\ufe6b\uff01-\uffee]
Datum (Jaar-Maand-Dag)	(\d{4}\|\d{2})-((0?([1-9]))\|(1[1\|2]))-((0?[1-9])\|([12]([1-9]))\|(3[0\|1]))
Datum (Maand/Dag/Jaar)	((0?[1-9]{1})\|(1[1\|2]))/(0?[1-9]\|([12][1-9])\|(3[0\|1]))/(\d{4}\|\d{2})
Tijd (Uur:Minuten, 24-uurs formaat)	((1\|0?)[0-9]\|2[0-3]):([0-5][0-9])
Vaste Telefoon in het Vasteland van China	(\d{4}-\|\d{3}-)?(\d{8}\|\d{7})
Mobiele Telefoon in het Vasteland van China	1\d{10}
Postcode in het Vasteland van China	[1-9]\d{5}
Identiteitskaartnummer in het Vasteland van China (15 of 18 cijfers)	\d{15}(\d\d[0-9xX])?
Niet-negatief Geheel Getal (Positief Getal of Nul)	\d+
Positief Geheel Getal	[0-9][1-9][0-9]
Negatief Geheel Getal	-[0-9][1-9][0-9]
Geheel Getal	-?\d+
Decimaal	(-?\d+)(\.\d+)?
Lege Regels	\n\s\r of \n\n(editplus) of ^[\s\S ]\n
QQ Nummer	[1-9]\d{4,}
Woord dat geen abc bevat	\b((?!abc)\w)+\b
Match Begin en Einde Witruimtes	^\s\|\s$
Bewerk Veelgebruikte	Hieronder zijn enkele vervangingen voor speciale Chinese karakters (editplus) ^[0-9].\n ^[^第].\n ^[习题].\n ^[\s\S ]\n ^[0-9]\. ^[\s\S ]\n <p[^<>]> href="javascript:if$confirm\('(.?)'$\)window\.location='(.?)'" <span style=".[^"]rgb$255,255,255$">.[^<>]</span> <DIV class=xs0>[\s\S]?</DIV>

RegEx Syntax Referentietabel - Veelgebruikte RegEx Technieken en Syntax

Reguliere expressies zijn krachtige tekstverwerkingstools, deze pagina biedt u een snelle referentietabel voor reguliere expressies, die u helpt de basis syntax van reguliere expressies, modifiers, subexpressies, greedy en non-greedy modes snel te begrijpen.

Basis Syntax van Reguliere Expressies

Reguliere expressies worden gebruikt om de regels van stringpatronen te beschrijven, en enkele veelvoorkomende basis syntax zijn:

De Punt (.) : Matcht elk enkel karakter (behalve nieuwe regels).
Karaktergroep ([ ]) : Matcht elk karakter binnen de haakjes. Bijvoorbeeld: [a-z] matcht alle kleine letters.
Uitsluiting van Karaktergroep ([^ ]) : Matcht elk karakter dat niet in de haakjes staat. Bijvoorbeeld: [^0-9] matcht niet-numerieke karakters.
Kwantoren (*, +, ?) : Duidt het aantal matches aan. Bijvoorbeeld: a* duidt aan dat er nul of meer a's gematcht worden.
Ankers (^, $) : ^ geeft het begin van de string aan, $ geeft het einde van de string.

Veelgebruikte Modifiers voor Reguliere Expressies

Modifiers voor reguliere expressies worden gebruikt om de matchregels van reguliere expressies te veranderen; veelvoorkomende modifiers zijn:

g (Globale Match) : Matcht alle overeenkomende strings, niet alleen de eerste.
i (Hoofdlettergevoelig) : Negeert de hoofdlettergevoeligheid tijdens de match.
m (Meerdere Regels) : Laat ^ en $ elke regel beginnen en eindigen.

Greedy en Non-Greedy Modus

In reguliere expressies zijn de kwantoren standaard greedy, wat betekent dat ze zoveel mogelijk karakters matchen. De non-greedy modus wordt gebruikt door ? na het kwantor te plaatsen, zoals hieronder:

Greedy Modus : a.*b matcht alle karakters tussen a en b (inclusief meerdere b's).
Non-Greedy Modus : a.*?b matcht zo min mogelijk karakters tussen a en b.

Subexpressies en Groeperen

Subexpressies in reguliere expressies worden gedefinieerd met haakjes (()), vaak gebruikt om de gematchte delen te extraheren. Groeperen wordt bereikt met het " | " teken. Bijvoorbeeld:

Subexpressie : (abc) matcht en vangt de string "abc".
Groep : (abc|def) matcht "abc" of "def".

Snelle Query voor Reguliere Expressies

Hieronder volgt een snelle query voor veelgebruikte reguliere expressies:

Functie	Reguliere Expressie
Match Cijfers	\d
Match Niet-Cijfers	\D
Match Letters	[a-zA-Z]
Match Elk Karakter	.
Match Witruimte Karakter	\s

Toepassingen van Reguliere Expressies

Reguliere expressies worden veel toegepast in de volgende scenario's:

Data validatie: zoals het valideren van het formaat van e-mailadressen, telefoonnummers, IP-adressen, enz.
Tekst zoeken: in teksten zoeken naar overeenkomende strings.
Data opschonen: gebruik maken van reguliere expressies om specifieke karakters of patronen te verwijderen of te vervangen.
Loganalyse: informatie uit logbestanden extraheren, specifieke logregels filteren.

Tips om Reguliere Expressies te Leren

Begin simpel: Beheers eerst de basis matchsymbolen en syntax en leer dan geleidelijk moeilijkere reguliere expressies.
Oefen veel: Versterk je begrip van reguliere expressies door praktische toepassingen.
Gebruik tools voor reguliere expressies: Gebruik testtools voor reguliere expressies om reguliere expressies te verifiëren en te debuggen.

Gebruik nu onze RegEx Syntax Referentietabel om uw efficiëntie bij het schrijven van reguliere expressies te verbeteren en uw tekstverwerkingsvaardigheden te versterken!