Regex syntax snabbreferens

Reguljära uttryck, även kända som mönsteruttryck, är en typ av textmönster som vanligtvis används för att söka, ersätta och kontrollera text. De består huvudsakligen av bokstäverna a till z samt några speciella metakaraktärer. Användningen av reguljära uttryck är mycket omfattande och de populariserades först av Unix, och används sedan allmänt i språk som Scala, PHP, C#, Java, C++, Objective-C, Perl, Swift, VBScript, Javascript, Ruby och Python. Att lära sig reguljära uttryck innebär i praktiken att man lär sig ett mycket flexibelt logiskt tänkande för att snabbt och enkelt kontrollera strängar.
Reguljära tecken Beskrivning
\ Markerar nästa tecken som ett speciellt tecken, ett litterärt tecken, en bakåtreferens, eller en oktal escape-sekvens. Till exempel, “n" matchar tecknet "n". "\n" matchar en ny rad. Sekvensen "\\" matchar "\" medan "\(" matchar "(".
^ Matcher början av den inmatade strängen. Om RegExp-objektets Multiline-egenskap är inställd på true, matchar ^ också positionen efter “\n" eller "\r".
$ Matcher slutet av den inmatade strängen. Om RegExp-objektets Multiline-egenskap är inställd på true, matchar $ också positionen före “\n" eller "\r".
* Matcher den föregående deluttrycket noll eller flera gånger. Exempelvis, zo* kan matcha “z" och "zoo". * är ekvivalent med {0,}.
+ Matcher den föregående deluttrycket en eller flera gånger. Till exempel, “zo+" kan matcha "zo" och "zoo", men kan inte matcha "z". + är ekvivalent med {1,}.
? Matcher den föregående deluttrycket noll eller en gång. Exempelvis, “do(es)?" kan matcha "does" eller "do" i "does". ? är ekvivalent med {0,1}.
{n} n är ett icke-negativt heltal. Matcher ett bestämt n-antal gånger. Exempelvis, “o{2}" kan inte matcha "Bob"s "o", men kan matcha de två o:n i "food".
{n,} n är ett icke-negativt heltal. Matcher minst n gånger. Exempelvis, “o{2,}" kan inte matcha "Bob"s "o", men kan matcha alla o:n i "foooood". "o{1,}" är ekvivalent med "o+". "o{0,}" är ekvivalent med "o*".
{n,m} m och n är båda icke-negativa heltal, där n<=m. Matcher minst n gånger och högst m gånger. Exempelvis, “o{1,3}" kommer att matcha de tre första o:n i "fooooood". "o{0,1}" är ekvivalent med "o?". Observera att det inte får finnas några mellanslag mellan kommat och de två siffrorna.
? När detta tecken omedelbart följer efter någon annan kvantifierare (*, +, ?, {n}, {n,}, {n,m}) matchar mönstret i icke-girig form. Icke-girig form matchar så få tecken som möjligt av det sökta mönstret, medan den standardmässiga giriga formen matchar så många som möjligt. Till exempel, för strängen “oooo", "o+?" kommer att matcha ett enda "o", medan "o+" kommer att matcha alla "o".
. Matcher vilken som helst av de enskilda tecknen, förutom “\n". För att matcha vilket tecken som helst, inklusive "\n", använd ett mönster som "(.|\n)".
(mönster) Matcher mönstret och fångar detta match. Den fångade matchen kan fås från den resulterande Matches-samlingen, i VBScript används SubMatches-samlingen, medan i JScript används $0…$9 egenskaper. För att matcha parentestecknet, använd “\(" eller "\)".
(?:mönster) Matcher mönstret men fångar inte resultatet, vilket innebär att detta är en icke-fångande match som inte sparas för senare användning. Detta är användbart när man använder "|"-tecknet för att kombinera olika delar av ett mönster. Till exempel "industr(?:y|ies)" är en mer kompakt uttryck än "industry|industries".
(?=mönster) Positiv lookahead, matchar i början av en sträng som matchar mönstret. Detta är en icke-fångande match, vilket betyder att den matchningen inte behöver fångas för senare användning. Till exempel, “Windows(?=95|98|NT|2000)" kan matcha "Windows" i "Windows2000", men kan inte matcha "Windows" i "Windows3.1". Lookahead konsumerar inga tecken, vilket innebär att efter en matchning inträffar, börjar nästa sökning direkt efter den senaste matchningen, istället för att börja från tecknet som innehåller lookahead.
(?!mönster) Negativ lookahead, matchar i början av en sträng som inte matchar mönstret. Detta är en icke-fångande match, vilket betyder att den matchningen inte behöver fångas för senare användning. Till exempel “Windows(?!95|98|NT|2000)" kan matcha "Windows" i "Windows3.1", men kan inte matcha "Windows" i "Windows2000". Lookahead konsumerar inga tecken, vilket betyder att efter en matchning inträffar, börjar nästa sökning direkt efter den senaste matchningen, istället för att börja från tecknet som innehåller lookahead.
(?<=mönster) Positiv lookbehind, liknande positiv lookahead men med omvänd riktning. Till exempel, “(?<=95|98|NT|2000)Windows" kan matcha "Windows" i "2000Windows", men kan inte matcha "Windows" i "3.1Windows".
(?<!mönster) Negativ lookbehind, liknande negativ lookahead men med omvänd riktning. Till exempel “(?<!95|98|NT|2000)Windows" kan matcha "Windows" i "3.1Windows", men kan inte matcha "Windows" i "2000Windows".
x|y Matcher x eller y. Till exempel, “z|food" kan matcha "z" eller "food". "(z|f)ood" matchar "zood" eller "food".
[xyz] Teckenklass. Matcher vilket av de inkluderade tecknen som helst. Till exempel, “[abc]" kan matcha "plain"s "a".
[^xyz] Negativ teckenklass. Matcher vilket tecken som helst som inte är inkluderat. Till exempel, “[^abc]" kan matcha "plain"s "p".
[a-z] Teckenintervall. Matcher vilket tecken som helst inom det angivna intervallet. Till exempel, “[a-z]" kan matcha vilket litet bokstavstecken som helst mellan "a" och "z".
[^a-z] Negativt teckenintervall. Matcher vilket tecken som helst som inte är inom det angivna intervallet. Till exempel, “[^a-z]" kan matcha vilket tecken som helst som inte är mellan "a" och "z".
\b Matcher ett ordgräns, vilket är positionen mellan ett ord och ett blanksteg. Till exempel, “er\b" kan matcha "never"s "er", men kan inte matcha "verb"s "er".
\B Matcher en icke-ordgräns. “er\B" kan matcha "verb"s "er", men kan inte matcha "never"s "er".
\cx Matcher en kontrolltecken som anges av x. Till exempel, \cM matchar en Control-M eller carriage return-tecken. x:s värde måste vara en av A-Z eller a-z. Annars kommer c att behandlas som ett litterärt "c"-tecken.
\d Matcher ett siffra. Ekvivalent med [0-9].
\D Matcher ett icke-siffra. Ekvivalent med [^0-9].
\f Matcher en sidbrytning. Ekvivalent med \x0c och \cL.
\n Matcher en ny rad. Ekvivalent med \x0a och \cJ.
\r Matcher ett carriage return-tecken. Ekvivalent med \x0d och \cM.
\s Matcher vilket som helst blanktecken, inklusive blanksteg, tabulatortecken, sidbrytningar, etc. Ekvivalent med [ \f\n\r\t\v].
\S Matcher vilket som helst icke-blanktecken. Ekvivalent med [^ \f\n\r\t\v].
\t Matcher ett tabulatortecken. Ekvivalent med \x09 och \cI.
\v Matcher ett vertikalt tabulatortecken. Ekvivalent med \x0b och \cK.
\w Matcher vilket som helst ordtecken inklusive understreck. Ekvivalent med “[A-Za-z0-9_]".
\W Matcher vilket som helst icke-ordtecken. Ekvivalent med “[^A-Za-z0-9_]".
\xn Matcher n, där n är ett hexadecimalt escape-värde. Det hexadecimala escape-värdet måste vara två bestämda siffror långt. Till exempel, “\x41" matchar "A". "\x041" är ekvivalent med "\x04&1". I regulära uttryck kan ASCII-kod användas.
\num Matcher num, där num är ett positivt heltal. Referens till den fångade matchningen. Till exempel, “(.)\1" matchar två på varandra följande samma tecken.
\n Identifierar ett oktalt escape-värde eller en bakåtreferens. Om \n föregås av minst n fångade deluttryck är n en bakåtreferens. Annars, om n är en octal siffra (0-7), är n ett oktalt escape-värde.
\nm Identifierar ett oktalt escape-värde eller en bakåtreferens. Om \nm föregås av minst nm fångade deluttryck är nm en bakåtreferens. Om \nm föregås av minst n fångade, är n en bakåtreferens som följs av litteralen m. Om inga av de föregående villkoren uppfylls, om n och m båda är oktala siffror (0-7), kommer \nm att matcha det oktala escape-värdet nm.
\nml Om n är en oktal siffra (0-3), och m och l båda är oktala siffror (0-7), matcher oktal escape-värdet nml.
\un Matcher n, där n är ett Unicode-tecken som representeras av fyra hexadecimala siffror. Till exempel, \u00A9 matchar upphovsrättssymbolen (©).
Vanligt använda reguljära uttryck
Användarnamn /^[a-z0-9_-]{3,16}$/
Lösenord /^[a-z0-9_-]{6,18}$/
Lösenord 2 (?=^.{8,}$)(?=.*\d)(?=.*\W+)(?=.*[A-Z])(?=.*[a-z])(?!.*\n).*$ (Består av siffror/stora bokstäver/lilla bokstäver/tecken, alla fyra måste finnas, minst 8 tecken)
Hexadecimal värde /^#?([a-f0-9]{6}|[a-f0-9]{3})$/
E-postadress /^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/
/^[a-z\d]+(\.[a-z\d]+)*@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/ eller \w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
URL /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/ eller [a-zA-z]+://[^\s]*
IP-adress /((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]?)$/ eller ((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)
HTML-tagg /^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/ eller <(.*)(.*)>.*<\/\1>|<(.*) \/>
Ta bort kod/kommentarer (?<!http:|\S)//.*$
Matcher dubbelbyte-karaktärer (inklusive kinesiska tecken) [^\x00-\xff]
Kinesiska tecken (tecken) [\u4e00-\u9fa5]
Område av kinesiska tecken i Unicode-kodning /^[\u2E80-\u9FFF]+$/
Kinesiska och fullbreddens punktsymboler (tecken) [\u3000-\u301e\ufe10-\ufe19\ufe30-\ufe44\ufe50-\ufe6b\uff01-\uffee]
Datum (år-månad-dag) (\d{4}|\d{2})-((0?([1-9]))|(1[1|2]))-((0?[1-9])|([12]([1-9]))|(3[0|1]))
Datum (månad/dag/år) ((0?[1-9]{1})|(1[1|2]))/(0?[1-9]|([12][1-9])|(3[0|1]))/(\d{4}|\d{2})
Tid (timmar:minuter, 24-timmarsformat) ((1|0?)[0-9]|2[0-3]):([0-5][0-9])
Fast telefonnummer i Kina (\d{4}-|\d{3}-)?(\d{8}|\d{7})
Mobilnummer i Kina 1\d{10}
Postnummer i Kina [1-9]\d{5}
Identitetsnummer i Kina (15 eller 18 siffror) \d{15}(\d\d[0-9xX])?
Icke-negativa heltal (positiva heltal eller noll) \d+
Positiva heltal [0-9]*[1-9][0-9]*
Negativa heltal -[0-9]*[1-9][0-9]*
Heltal -?\d+
Decimaltal (-?\d+)(\.\d+)?
Tom rad \n\s*\r eller \n\n(editplus) eller ^[\s\S ]*\n
QQ-nummer [1-9]\d{4,}
Matcher ord utan abc \b((?!abc)\w)+\b
Matcher inledande och avslutande blanktecken ^\s*|\s*$
Redigeringsvanor
Följande är några ersättningar för specifika kinesiska tecken (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>

Snabbguide till Reguljära Uttryck - Vanliga tekniker och syntax

Reguljära uttryck är ett kraftfullt verktyg för textbehandling, denna sida erbjuder en snabbguide för reguljära uttryckssyntaxer, som hjälper dig att snabbt förstå grunderna i reguljära uttryck, modifierare, deluttryck, giriga och icke-giriga mönster osv.

Grunderna för reguljära uttryck

Reguljära uttryck används för att beskriva regler för strängmönster, vanliga grundläggande syntaxer inkluderar:

Vanliga modifierare för reguljära uttryck

Reguljära modifierare används för att ändra matchningsreglerna för reguljära uttryck, vanliga modifierare inkluderar:

Girig och icke-girig matchning

I reguljära uttryck är kvantifierare som standard giriga, vilket innebär att de försöker matcha så många tecken som möjligt. Icke-girig mönster kan användas genom att lägga till ? efter kvantifieraren, se exempel nedan:

Deluttryck och gruppering

Deluttryck i reguljära uttryck definieras med parenteser (()), används ofta för att extrahera matchande delar. Gruppering görs med "|" tecknet. Till exempel:

Snabb sökning av reguljära uttryck

Följande är en snabb sökning av vanliga reguljära uttryck:

Funktion Reguljärt uttryck
Matchar siffror \d
Matchar icke-siffror \D
Matchar bokstäver [a-zA-Z]
Matchar vilket tecken som helst .
Matchar blanktecken \s

Användningsområden för reguljära uttryck

Reguljära uttryck används ofta inom följande områden:

Tips för att lära sig reguljära uttryck

Använd omedelbart vår Snabbguide till reguljära uttryckssyntaxer för att bli mer effektiv när du skriver reguljära uttryck, och förbättra din textbehandlingsförmåga!

Dina fotspår:
Välj språk