Testa reguljära uttryck med realtids markering av träffar, mönstervalidering och förklaringar av vanliga regex-symboler. Spara och återanvänd dina ofta använda mönster med anpassade etiketter.
Ange ett mönster och testtext för att se resultat
Ange ett mönster och testtext för att se resultat
Inga sparade mönster ännu
.Matchar vilket tecken som helst utom radbrytning\dMatchar vilken siffra som helst (0-9)\DMatchar vilken icke-siffra som helst\wMatchar vilket ordtecken som helst (a-z, A-Z, 0-9, _)\WMatchar vilket icke-ordtecken som helst\sMatchar vilket vitrymdstecken som helst\SMatchar vilket icke-vitrymdstecken som helst^Matchar början av raden$Matchar slutet av raden*Matchar 0 eller fler av det föregående tecknet+Matchar 1 eller fler av det föregående tecknet?Matchar 0 eller 1 av det föregående tecknet{n}Matchar exakt n av det föregående tecknet{n,}Matchar minst n av det föregående tecknet{n,m}Matchar mellan n och m av det föregående tecknet[abc]Matchar vilket som helst av tecknen i klamrarna[^abc]Matchar vilket tecken som helst som inte finns i klamrarna(abc)Grupperar flera token tillsammans och fångar matchningena|bMatchar antingen a eller b\bMatchar en ordgränspositionEn Regular Expression (regex) mönster tester är ett viktigt verktyg för utvecklare, dataanalytiker och alla som arbetar med textbehandling. Denna omfattande regex-mönster validator låter dig skapa, testa och förfina reguljära uttryck i realtid, vilket ger omedelbar visuell feedback på mönstermatcher. Oavsett om du validerar e-postadresser, parser loggfiler eller extraherar specifika data från text, gör vår regex-tester utvecklings- och felsökningsprocessen snabbare och mer intuitiv.
Reguljära uttryck är kraftfulla mönstermatchande sekvenser som möjliggör sofistikerad textsökning, validering och manipulation. Men deras syntax kan vara komplex och svår att bemästra. Denna regex-mönster tester förenklar processen genom att markera matcher när du skriver, validera mönstersyntax och låta dig spara ofta använda mönster för framtida referens.
Att använda vår regex-mönster validator är enkelt och intuitivt. Följ dessa steg för att komma igång:
Ange ett reguljärt uttrycksmönster: Skriv ditt regex-mönster i det angivna inmatningsfältet. Verktyget validerar ditt mönster i realtid och varnar dig för eventuella syntaxfel.
Välj Regex-flaggor: Välj lämpliga flaggor för ditt mönster:
g (Global): Hitta alla matcher istället för att stanna efter den första matcheni (Case Insensitive): Gör mönstret skiftlägesokänsligtm (Multiline): Gör så att ^ och $ matchar början/slutet av varje radAnge testtext: Skriv in den text du vill testa mot ditt mönster i testtextområdet.
Visa resultat i realtid: När du skriver, markerar verktyget automatiskt:
Spara användbara mönster: För mönster som du använder ofta:
Kopiera resultat: Använd knappen "Kopiera matcher" för att kopiera all matchad text till ditt urklipp för användning i andra applikationer.
Gränssnittet är indelat i två huvudpaneler: inmatningspanelen där du anger ditt mönster och testtext, och resultatpanelen som visar matcher och mönsterinformation.
Reguljära uttryck använder specialtecken och sekvenser för att definiera sökmönster. Här är en guide till de grundläggande regex-symbolerna som stöds av vårt verktyg:
| Symbol | Beskrivning | Exempel | Matcher |
|---|---|---|---|
. | Matcher vilket tecken som helst förutom radbrytning | a.c | "abc", "adc", "a1c", etc. |
\d | Matcher vilken siffra som helst (0-9) | \d{3} | "123", "456", "789", etc. |
\D | Matcher vilket icke-siffra | \D+ | "abc", "xyz", etc. |
\w | Matcher vilket ordtecken (a-z, A-Z, 0-9, _) | \w+ | "abc123", "test_123", etc. |
\W | Matcher vilket icke-ordtecken | \W+ | "!@#", " + ", etc. |
\s | Matcher vilket blanktecken | a\sb | "a b", "a\tb", etc. |
\S | Matcher vilket icke-blanktecken | \S+ | "abc", "123", etc. |
| Symbol | Beskrivning | Exempel | Matcher |
|---|---|---|---|
^ | Matcher början av rad | ^abc | "abc" i början av en rad |
$ | Matcher slutet av rad | abc$ | "abc" i slutet av en rad |
\b | Matcher en ordgräns | \bword\b | "word" som ett komplett ord |
| Symbol | Beskrivning | Exempel | Matcher |
|---|---|---|---|
* | Matcher 0 eller fler av det föregående tecknet | a*b | "b", "ab", "aab", etc. |
+ | Matcher 1 eller fler av det föregående tecknet | a+b | "ab", "aab", "aaab", etc. |
? | Matcher 0 eller 1 av det föregående tecknet | colou?r | "color", "colour" |
{n} | Matcher exakt n av det föregående tecknet | a{3} | "aaa" |
{n,} | Matcher minst n av det föregående tecknet | a{2,} | "aa", "aaa", "aaaa", etc. |
{n,m} | Matcher mellan n och m av det föregående tecknet | a{2,4} | "aa", "aaa", "aaaa" |
| Symbol | Beskrivning | Exempel | Matcher |
|---|---|---|---|
[abc] | Matcher vilket tecken som helst i klammerparentesen | [aeiou] | "a", "e", "i", "o", "u" |
[^abc] | Matcher vilket tecken som helst som inte finns i klammerparentesen | [^aeiou] | Vilket tecken som helst utom "a", "e", "i", "o", "u" |
[a-z] | Matcher vilket tecken som helst i intervallet | [a-z] | Vilken som helst liten bokstav |
| Symbol | Beskrivning | Exempel | Matcher |
|---|---|---|---|
(abc) | Grupperar flera token tillsammans och fångar matchen | (abc)+ | "abc", "abcabc", etc. |
a|b | Matcher antingen a eller b | cat|dog | "cat", "dog" |
När du har bemästrat grunderna kan du skapa mer sofistikerade mönster för att lösa komplexa textbehandlingsutmaningar:
1^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
2Detta mönster validerar e-postadresser genom att säkerställa att de följer standardformatet: användarnamn@domän.tld.
1^(https?:\/\/)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)$
2Detta mönster validerar URL:er, inklusive de med eller utan http/https-protokoll.
1^\(?(\d{3})\)?[- ]?(\d{3})[- ]?(\d{4})$
2Detta mönster matchar amerikanska telefonnummer i olika format: (123) 456-7890, 123-456-7890 eller 1234567890.
1^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$
2Detta mönster validerar datum i formatet YYYY-MM-DD, med grundläggande validering för månad- och dagintervall.
Lookahead- och lookbehind-assertioner låter dig matcha mönster endast om de följs av eller föregås av ett annat mönster:
a(?=b) matchar "a" endast om det följs av "b"a(?!b) matchar "a" endast om det inte följs av "b"(?<=a)b matchar "b" endast om det föregås av "a"(?<!a)b matchar "b" endast om det inte föregås av "a"Vår regex-tester stöder olika flaggor som modifierar hur mönster matchas:
^ och $ matchar början/slutet av varje radReguljära uttryck har många praktiska tillämpningar inom olika områden:
Formvalidering: Säkerställ att användarinmatningar matchar nödvändiga format:
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$HTML-parsing: Extrahera specifika element eller attribut:
<img[^>]+src="([^">]+)"<a[^>]+href="([^">]+)"Loggfilsanalys: Extrahera information från loggposter:
\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}ERROR: .*CSV-parsing: Bearbeta kommatecken-separerade värden med potentiella citerade fält:
(?:^|,)(?:"([^"]*(?:""[^"]*)*)"|([^,]*))Hitta och ersätta: Identifiera mönster för ersättning:
<[^>]*>(\d{3})(\d{3})(\d{4}) → ($1) $2-$3Innehållsextraktion: Dra specifik information från ostrukturerad text:
\b(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2},\s+\d{4}\b\$\d+(?:\.\d{2})?Syntaxmarkering: Identifiera språkstrukturer:
\b(?:var|let|const)\s+([a-zA-Z_$][\w$]*)\bfunction\s+([a-zA-Z_$][\w$]*)\s*\(Kodrefaktorering: Hitta mönster som behöver uppdatering:
\.oldMethod\(eval\(Vår regex-mönster tester inkluderar ett mönsterhanteringssystem som låter dig spara och återanvända dina ofta använda uttryck:
Överväg att spara mönster som:
När du sparar mönster, använd beskrivande etiketter som:
Organisera dina sparade mönster efter:
Även om vårt verktyg inte direkt stöder mönsterdelning mellan användare kan du:
Även erfarna utvecklare stöter på utmaningar med reguljära uttryck. Här är lösningar på vanliga problem:
Om ditt mönster visar ett valideringsfel:
Om din regex är långsam eller orsakar webbläsarfördröjning:
(a+)+)Om ditt mönster matchar oönskad text:
^ och $) för att matcha hela strängar\b) där det är lämpligtOm ditt mönster inte matchar förväntad text:
i-flaggan)Även om regex är kraftfullt, är det inte alltid den bästa lösningen för varje textbehandlingsuppgift:
För enkla textoperationer är inbyggda strängmetoder ofta tydligare och mer effektiva:
String.indexOf() för att hitta delsträngarString.startsWith() och String.endsWith() för att kontrollera stränggränserString.split() för grundläggande tokeniseringFör strukturerade dataformat är dedikerade parsers mer robusta:
För att förstå textens mening snarare än bara mönster:
Överväg alternativ till regex när:
Ett reguljärt uttryck (regex) är en sekvens av tecken som definierar ett sökmönster. Dessa mönster kan användas för strängsökning, matchning och textmanipulationsoperationer.
En regex-mönster tester hjälper dig att utveckla och felsöka reguljära uttryck genom att ge omedelbar visuell feedback på matcher, validera mönstersyntax och låta dig experimentera med olika mönster och flaggor utan att behöva implementera dem i kod först.
För att matcha bokstavliga specialtecken som normalt har en speciell betydelse i regex, måste du undanta dem med en backslash. Till exempel, för att matcha en bokstavlig punkt, använd \. istället för bara ..
.* och .*? i ett regex-mönster?.* är en girig kvantifierare som matchar så många tecken som möjligt, medan .*? är en lat (icke-girig) kvantifierare som matchar så få tecken som möjligt. Denna skillnad är viktig när du vill hitta den kortaste matchningen snarare än den längsta.
Även om kärnregex-syntaxen är liknande över många språk, finns det subtila skillnader i implementeringen. Vår tester använder JavaScripts regex-motor, som är kompatibel med många webbprogrammeringsspråk men kan ha skillnader från regex i språk som Python, Java eller Perl.
För att validera att en hel sträng matchar ett mönster, använd ankaret ^ i början och ankaret $ i slutet av din regex. Till exempel, ^[0-9]+$ kommer endast att matcha strängar som helt består av siffror.
Fångande grupper, skapade med parenteser (), låter dig extrahera specifika delar av den matchade texten. I vår tester kan du se alla matcher, inklusive fångade grupper. I programmeringsspråk kan du vanligtvis komma åt dessa fångster genom att indexera matchresultatet.
För att förbättra regex-effektiviteten: var specifik med teckenklasser, undvik onödiga fångande grupper (använd icke-fångande grupper (?:...) när det är möjligt), begränsa användningen av lookaheads/lookbehinds, och undvik katastrofal bakspårning av mönster som nästlade kvantiteter.
Vanliga misstag inkluderar: att inte undanta specialtecken, skapa mönster som är för giriga, glömma att ankra mönster (med ^ och $), och skriva överdrivet komplexa uttryck som är svåra att underhålla.
Reguljära uttryck är inte väl lämpade för att parsa nästlade strukturer som HTML eller XML. Även om du kan skapa regex-mönster för enkel HTML-matchning, är det generellt bättre att använda en dedikerad HTML-parser för komplex HTML-bearbetning.
Prova vår regex-mönster tester idag för att förenkla dina textbehandlingsuppgifter, validera inmatningsformat och extrahera meningsfull data från ostrukturerad text. Oavsett om du är nybörjare som lär dig grunderna i reguljära uttryck eller en erfaren utvecklare som arbetar med komplex mönstermatchning, erbjuder vårt verktyg de funktioner du behöver för att skapa, testa och förfina dina regex-mönster effektivt.
Upptäck fler verktyg som kan vara användbara för din arbetsflöde