c regex tutorial what is c regular expression
Denna C # Regex-handledning förklarar vad som är ett vanligt uttryck i C #, dess syntax, Regex-klassmetoder och hur man använder dessa metoder med hjälp av exempel:
Det reguljära uttrycket i C # används för att matcha ett visst teckenmönster. Regelbundna uttryck används när en användare behöver hitta något upprepande mönster eller göra en datavalidering eller till och med för att kontrollera dataformatering.
En RegEx används för att hitta om en sträng innehåller eller matchar ett visst teckenmönster. En regex är främst en karaktärsekvens som betecknar ett mönster.
Ett mönster kan vara allt från siffror, tecken eller en kombination av alla. Regex används ofta för validering. Analysera eller matcha strängar, till exempel, hitta om en sträng matchar valutaformat, telefonnummer eller datumformat.
=> Läs igenom Easy C # Training Series.
intervjufrågor och svar om kvalitetssäkringsanalytiker
Vad du kommer att lära dig:
Regex klass i C #
Regex-klass används i C # för att utföra regex-operationer. Den innehåller flera olika metoder som kan användas för att utföra olika operationer relaterade till regex.
Den kan användas för att analysera stor text för att hitta en viss teckensekvens genom att använda metoder som kan användas för att utföra en matchning, för att ersätta eller kan användas för att dela teckensekvensen.
Regex-klassen finns i namnområdet; System.Text.RegularExpression. Klassen accepterar en sträng i form av en teckenföljd som parameter.
C # Regex-metoder
IsMatch
Den enklaste och mest användbara metoden i Regex-klassen är IsMatch-metoden. Denna metod har olika överbelastningar för att utföra matchning av tecken baserat på olika parametrar.
Den enklaste är IsMatch (strängtext) , den här metoden tillåter användaren att tillhandahålla en teckenföljd för att matcha en sträng.
Den andra överbelastningen IsMatch (strängtext, int-position). Den här metoden returnerar ett booleskt värde och tar två parametrar (sträng och heltal). Strängtexten som anges i parametern är i grunden en regex-konstruktör som matchar teckensekvensen från startpositionen som anges av heltalsparametern.
Således kommer denna metod att försöka matcha stränginmatningen vid den position som tillhandahålls av ett heltalsparameter i en given sträng.
Den tredje överbelastningen, IsMatch (strängtext, strängmönster) accepterar två parametrar och returnerar ett booleskt värde. Den första parametern är text där användaren behöver hitta ett mönster och nästa parameter ger det mönster som användaren söker i den givna texten.
Rekommenderad läsning = >> Mönstermatchning i MySQL
Ersätt (strängtext, strängersättningstext)
Ersättningsmetoden accepterar två parametrar och returnerar ett strängvärde. Den första parametern är teckensekvensen eller regexen som du vill använda för matchning och den andra ersätter regexen.
Metoden fungerar genom att hitta en matchning av den givna texten och sedan ersätta den med den ersättningstext som tillhandahålls av användaren. Metodens signatur är public string Ersätt (strängtext, strängersättningText)
Offentlig sträng () Dela (strängtext)
Delningsmetoden från regex-klassen accepterar stränginmatning som en parameter och returnerar en matris som innehåller understrängar. Parametern som skickas i metoden är strängen som måste delas.
Metoden hittar det matchande inmatningsmönstret i strängen och när den identifierar något matchande mönster, delar den strängen på den platsen i mindre strängar med varje matchande mönster som brytpunkt. Metoden returnerar sedan en matris som innehåller alla underlag.
Användning av Regex C # -metoder
Låt oss titta på användningen av dessa metoder genom att skriva ett enkelt program.
public static void Main(string() args) { string patternText = 'Hello'; Regex reg = new Regex(patternText); //IsMatch(string input) Console.WriteLine(reg.IsMatch('Hello World')); //IsMatch(string input, int index) Console.WriteLine(reg.IsMatch('Hello', 0)); //IsMatch(string input, string pattern) Console.WriteLine(Regex.IsMatch('Hello World', patternText)); //Replace(string input, string replacement) Console.WriteLine(reg.Replace('Hello World', 'Replace')); //Split(string input, string pattern) string() arr = Regex.Split('Hello_World_Today', '_'); foreach(string subStr in arr) { Console.WriteLine('{0}', subStr); } }Resultatet från ovanstående program
Sann
Sann
Sann
Byt ut världen
Hallå
Värld
I dag
Förklaringen till ovanstående kod:
I början av programmet har vi skapat ett objekt och för mönstret som vi kommer att använda för kodmatchning i den efterföljande stränginmatningen har vi använt textformatering för att hålla sakerna enkla i början men om du är bekväm kan du börja använda mönster för reguljära uttryck. (Vi kommer att diskutera regelbundet uttrycksmönster i detalj när vi går vidare i denna handledning)
Sedan använder vi matchningssträng för att mata in den faktor som vi har deklarerat som det angivna objektet med inmatningssträngen och om den matchar kommer den att returnera för att returnera falskt.
Nästa metod vi använde är IsMethod (stränginmatning, int-index). Denna metod accepterar tvåparametrar, och här tillhandahåller vi inmatningssträng och indexet från vilket matchningen måste börja. Till exempel, här ville vi starta matchningen från början av inmatningssträngen.
Sedan demonstrerade vi användningen av IsMatch (stränginmatning, strängmönster). Här tillhandahöll vi inmatningssträngen då vi ville ta reda på att om mönstertexten finns i inmatningen eller inte. Om det är nu kommer det att återvända sant (som i vårt fall) annars kommer det att returnera falskt.
En annan metod som vi diskuterade ersätts. Denna metod är ganska användbar i program där du vill göra ändringar i indata eller ändra format på befintlig data.
Här tillhandahåller vi två parametrar, den första är ingångssträngen och den andra är strängen som kan användas för att ersätta den tidigare strängen. Denna metod använder också mönstret som definierats i regex-objektet som vi definierade tidigare.
En annan viktig metod som vi använde är split. Denna metod används för att dela upp den givna strängen baserat på vissa återkommande mönster. Här har vi tillhandahållit en sträng “Hello_World_Today”.
Låt oss säga att vi vill ta bort understrykningen från den givna strängen och få delarna. För detta specificerar vi ingångsparametern och sedan ger vi det mönster som vi behöver använda som delningspunkt. Metoden returnerar en matris och vi kan använda en enkel slinga som foreach för att hämta alla strängar.
Regular Expression Syntax
Det finns flera olika syntaxer som specialtecken, kvantifierare, teckenklasser etc. som kan användas för att matcha ett visst mönster från en given ingång.
I denna del av handledningen kommer vi att dyka djupt in i syntaxen som erbjuds av regex och försöka lösa några verkliga scenarier med dem. Innan vi fortsätter, se till att du fick grundidén om regex och de olika metoderna som finns tillgängliga inom regex-klassen.
Speciella karaktärer
Specialtecken i en regex används för att tilldela ett mönster flera olika betydelser. Vi kommer nu att titta på några av de allmänt använda specialtecknen och deras betydelse i Regex.3
| Speciella karaktärer | Menande |
|---|---|
| w och W | Små bokstäver 'w' används för att matcha alfanumeriska / understrykningstecken och versaler 'W' används för att matcha icke-ordstecken. |
| ^ | Detta är en av de mest använda syntaxerna. Det betecknar början, ordet eller mönstret efter det att detta börjar matcha från början av inmatningstexten. |
| $ | Detta tecken används för att matcha ord från slutet av strängen. Ord / mönster som betecknas före denna symbol kommer att matcha de ord som finns i slutet av strängen. |
| . (punkt) | Dot används för att matcha ett enstaka tecken i den givna strängen som förekommer en gång. |
| n | Detta används för en ny linje. |
| d och D | Små bokstäver 'd' används för att matcha ett siffratecken och versaler 'D' används för att matcha icke-siffriga tecken. |
| s och S | Små bokstäver 's' används för att matcha vita mellanrum och versaler 'S' används för att matcha icke-vitt mellanrum. |
Kvantifierarsyntax
Kvantifierarsyntax används för att räkna eller kvantifiera matchningskriterierna. Till exempel, om du vill kontrollera om en viss sträng innehåller ett alfabet en eller flera gånger. Låt oss ta en titt på några av de ofta använda kvantifierarna i Regular expression.
| Kvantifierarsyntax | Menande |
|---|---|
| * | Denna symbol används för att matcha föregående tecken. |
| + | Denna symbol används för att matcha ett eller flera tecken i rad. |
| {n} | Den numeriska siffran inuti de lockiga hakparenteserna används för att matcha numret på föregående tecken definierat av numeriska inuti lockiga hakparenteser. |
| {n,} | Siffran inuti lockiga hakparenteser och den här symbolen används för att se till att den matchar minst n (dvs. siffervärdet inuti hängslen). |
| {n, m} | Denna symbol används för att matcha från föregående tecken från n antal gånger till m antal gånger. |
| ? | Denna symbol gör att föregående tecken matchar som valfritt. |
Karaktärsklass
Teckenklassen är också känd som teckenuppsättningar, och detta används för att berätta för regex-motorn att leta efter en enstaka match av flera tecken. En karaktärsklass matchar endast ett tecken och ordningen på karaktärerna i teckenuppsättningen spelar ingen roll.
| Karaktärsklass | Menande |
|---|---|
| (intervall) | Symbolen för hakparentes används för att matcha ett antal tecken. Vi kan till exempel använda den för att definiera vilket tecken som helst i alfabetet 'a' till 'z' genom att stänga avståndet inom fästet som (a-z) Eller så kan vi också matcha det numeriska “1” till “9” genom att beteckna (1-9) |
| (^ intervall) | Detta betecknar förnekad karaktärsklass. Den används för att matcha vad som helst, inte i det intervall som anges inom fästet. |
| Detta används för att matcha specialtecken som kan ha sina egna regex-symboler. Snedstrecket används för att matcha specialtecken i deras bokstavliga form. |
Gruppering
Runda parenteser eller parenteser kan användas för att gruppera en del av det reguljära uttrycket tillsammans. Detta tillåter användaren att antingen lägga till en kvantifierare med uttrycket.
| Gruppering | Menande |
|---|---|
| (grupputtryck) | De runda parenteserna används för att gruppera ett uttryck. |
| | | | operatören används inuti det runda fästet för att använda ett alternativ till exempel (a | b). |
C # Exempel på reguljära uttryck
I föregående avsnitt lärde vi oss om symbolerna för reguljära uttryck, i det här avsnittet kommer vi att titta i detalj om användningen av olika symboler i Regular expression och kombinationen där de kan användas för att matcha olika uttryck.
I denna handledning kommer vi att diskutera några av de mest förekommande verkliga scenarierna som du kan möta som utvecklare när du arbetar med någon applikation eller i ett enkelt program för att få användarinmatning.
Exempel på reguljärt uttryck med verkliga scenarier
Låt oss lära oss mer om reguljära uttryck med några exempel i realtid.
Scenario 1: Validera om inmatningssträngen består av 6-siffriga skiftlägeskänsliga alfabetstecken.
Ett vanligaste scenario för reguljärt uttryck är att hitta och matcha ett visst ord. Till exempel, låt oss säga att jag vill ha en slumpmässig alfabetisk sträng från användaren och att ingången ska vara exakt sex siffror lång.
För att bekräfta att vi kan använda ett enkelt reguljärt uttryck. Låt oss skriva ett program för att förstå skrivandet och användningen av reguljära uttryck på ett bättre sätt.
public static void Main(string() args) { string patternText = @'^(a-zA-Z){6}$'; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch('Helios')); //When pattern doesnt match Console.WriteLine(reg.IsMatch('Helo')); }Produktion
Sann
Falsk
Förklaring
I det här exemplet försöker vi validera en inmatningssträng för att kontrollera om den innehåller sexsiffriga alfabetiska tecken. Tecknen kan vara både små och stora, så vi måste också ta hänsyn till det.
Så här definierade vi ett regelbundet uttrycksmönster i variabeln 'mönsterText' och skickade det sedan till regex-objektet. Nu är nästa kodrader ganska enkla, vi använde IsMatch-metoden för att jämföra det reguljära uttrycket och inmatningssträngen.
Låt oss nu titta på det vanliga uttrycket som vi har tagit fram. Uttrycket (^ (a-zA-Z) {6} $) består av fyra olika delar. “^”, “(A-zA-Z)”, “{6}” och “$”. Den andra delen betecknar de matchande tecknen som används för att utföra uttrycksmatchning, 'a-z' för gemener och 'A-Z' för stora bokstäver.
Den första delens karaktär “^” säkerställer att strängen börjar med ett mönster definierat i den andra delen, dvs. små och stora bokstäver.
De lockiga hakparenteserna i den tredje delen bestämmer antalet tecken i strängen som kan identifieras med det definierade mönstret, dvs. 6 i detta fall och symbolen “$” ser till att den slutar med det mönster som definieras i den andra delen.
^ (a-zA-Z) {6} $
Scenario 2: Använd reguljärt uttryck för att validera att ett ord som börjar med 'Super' och har vitt mellanslag efter det, dvs. för att validera om 'Super' finns i början av en mening.
Låt oss anta att vi läser lite användarinmatning och måste se till att användaren alltid startar sin mening med ett visst ord, nummer eller alfabet. Detta kan uppnås ganska enkelt med ett enkelt reguljärt uttryck.
Låt oss titta på ett exempelprogram och sedan diskutera i detalj om hur man skriver detta uttryck.
public static void Main(string() args) { string patternText = @'^Supers'; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch('Super man')); //When pattern doesnt match Console.WriteLine(reg.IsMatch('Superhero')); }Produktion
Sann
Falsk
Förklaring
I det här exemplet använde vi också en liknande kodinställning som vi gjorde i den första. Regeluttrycksmönstret i detta scenario kräver matchning med en kombination av ord eller meningar som börjar med “Super”.
^ Super
Så när vi vill matcha från början av ordserien kommer vi att börja med att sätta symbolen “^” och sedan ge det mönster som vi vill matcha, i detta fall “Super”. Nu kan mönstret som vi skapade ”^ Super” matcha med alla värderingar av super, till och med superman eller övernaturligt men vi vill inte bara ha ordet ”Super”.
Det betyder att det ska finnas ett blanksteg efter ordet för att markera slutet på ordet och börja på ett annat ord. För att göra det lägger vi till symbolen “ s” i mönstret och därigenom gör vårt slutliga mönster som
^ Super s
Scenario 3: Använd Regular expression för att hitta giltiga filnamn med ett filtypstillägg.
Ett annat viktigt realtidsscenario som utvecklare ofta möter är validering av filtyper. Låt oss säga att vi har en uppladdningsknapp i användargränssnittet, som bara kan acceptera filtillägg för bildfiler.
Vi måste validera användarens uppladdningsfil och informera honom om han laddade upp fel filformat. Detta kan enkelt uppnås med hjälp av Regular expression.
Nedan finns ett enkelt program för att kontrollera detta.
public static void Main(string() args) jpegProduktion
Sann
Sann
Sann
Falsk
Falsk
Förklaring
Här måste vi matcha ett filnamn. Ett giltigt filnamn består av tre delar ( filnamn +. + filtillägg ). Vi måste skapa ett regelbundet uttryck för att matcha alla tre delarna. Låt oss börja med att matcha den första delen, dvs namnet på filen. Ett filnamn kan innehålla alfanumeriska tecken och specialtecken.
Som diskuterats tidigare är symbolen för att beteckna ' w'. Dessutom kan filnamnet bestå av ett eller flera tecken så att symbolen “+” används. Kombinera dem så får vi symbolen för den första delen.
(w+)Fästet separerade detta i delar. Nästa del är pricksymbolen. Eftersom pricksymbolen har sin betydelse i en regex kommer vi att använda en backslash innan den för att ge den en bokstavlig betydelse. Kombinera båda och vi täcker de två första delarna av regexen.
(w+).Nu, för den tredje och sista delen, kan vi direkt definiera de nödvändiga filtilläggen åtskilda av '|' ELLER-symbolen. Detta kan sedan separeras genom att hänga in i ett cirkulärt fäste. Ett “$” -tecken i slutet ser till att de definierade tilläggen finns i slutet av strängen. Nu ska vi kombinera dem för att få det sista reguljära uttrycket.
(w+).(jpg|png|jpeg|gif)$Om vi nu använder detta i programmet kan vi se att det matchar rätt format och returnerar true men med ogiltiga format returnerar det false.
Scenario 4: Använd Regular expression för att validera ett webbadressformat
Låt oss anta att vi har ett webbformulär som accepterar en webbadress eller domänadress. Vi vill att användaren ska ange rätt webb- / domänadress medan han fyller i formuläret. För att avgöra om användaren har angett en korrekt webbadress kan ett reguljärt uttryck vara ganska användbart.
public static void Main(string() args) { string patternText = @'^www.(a-zA-Z0-9){3,20}.(com|in|org|co.in|net|dev)$'; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch('www.selenium.dev')); //When pattern doesnt match Console.WriteLine(reg.IsMatch('ww.alsjk9874561230.movie.dont')); }Produktion
Sann
Falsk
Förklaring
Här vill vi matcha ett giltigt domännamn med hjälp av ett reguljärt uttryck. Ett giltigt domännamn börjar med förkortningen 'www' följt av en punkt (.), Därefter namnet på webbplatsen efter det en punkt (.) Och i slutet en domänförlängning.
Så, i likhet med föregående scenario, försöker vi matcha det del för del. Låt oss först börja med att matcha 'www.' Del. Så vi börjar med startsymbolen, sedan som 'www.' Det är något som är fixat, så vi använder startsymbolen följt av de exakta orden för att matcha.
“^www.”Sedan börjar vi arbeta med den andra delen. Den andra delen av webbadressen kan vara vilket alfanumeriskt namn som helst. Så här kommer vi att använda hakparenteser som finns i teckenklassen för att definiera det intervall som måste matchas. Efter att ha lagt till den andra delen med den andra delen kommer att ge oss.
“^www.(a-zA-Z0-9){3,20}”Här har vi också lagt till lockiga hängslen för att definiera minsta och maximala teckenlängd för webbplatsens namn. Vi har gett minst 3 och högst 20. Du kan ange vilken minsta eller maximal längd du vill.
Nu, efter att ha täckt den första och andra delen av webbadressen, har vi bara den sista delen, dvs. domänförlängning. Det är ganska likt det vi gjorde i det senaste scenariot, vi matchar direkt domäntilläggen genom att använda OR och bifoga alla giltiga domänförlängningar i den cirkulära fästet.
Således om vi lägger till alla dessa tillsammans kommer vi att ha ett fullständigt reguljärt uttryck för att matcha alla giltiga webbadresser.
www.(a-zA-Z0-9){3,20}.(com|in|org|co.in|net|dev)$Scenario 5: Använd Regular expression för att validera ett e-post-id-format
Låt oss anta att vi har ett inloggningsformulär på vår webbsida som ber användarna att ange sin e-postadress. Av uppenbara skäl vill vi inte att vårt formulär ska gå vidare med ogiltiga e-postadresser. För att verifiera om e-postadressen som användaren anger är korrekt eller inte kan vi använda ett reguljärt uttryck.
Nedan följer ett enkelt program för att validera en e-postadress.
public static void Main(string() args) { string patternText = @'^(a-zA-Z0-9._-){5,25}.@.(a-z){2,12}.(com|org|co.in|net)'; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch('software_test123@gmail.com')); Console.WriteLine(reg.IsMatch('Special.Char@yahoo.co.in')); //When pattern doesnt match Console.WriteLine(reg.IsMatch('ww.alsjk9874561230.mo@vie.dont')); }Produktion
Sann
Sann
Falsk
Förklaring
En giltig e-postadress innehåller alfabet, siffror och några specialtecken som punkt (.), Bindestreck (-) och understrykning (_) följt av symbolen “@” som sedan följs av domännamnet och domänförlängningen.
Således kan vi dela upp e-postadressen i fyra delar, dvs. e-postidentifierare, '@' -symbolen, domännamnet och den sista är domäntillägget.
Låt oss börja med att skriva ett reguljärt uttryck för den första delen. Det kan vara alfanumeriskt med vissa specialtecken. Antag att vi har en uttrycksstorlek som sträcker sig från 5 till 25 tecken. På samma sätt som vi skrev det tidigare (i e-postscenariot) kan vi komma med följande uttryck.
^(a-zA-Z0-9._-){5,25}Nu går vi till andra delen. Det är relativt enkelt eftersom vi bara måste matcha en symbol, dvs '@'. Att lägga till det i ovanstående uttryck ger oss.
^(a-zA-Z0-9._-){5,25}.@Att flytta till den tredje delen, dvs. domännamnet, kommer alltid att vara en serie små bokstäver. Om du vill kan du också inkludera alfabetiska siffror eller versaler men för det här scenariot kommer vi att använda små bokstäver.
Om vi lägger till uttrycket för små bokstäver med en längd som sträcker sig från 2 till 12 tecken, kommer vi att ha följande uttryck.
^(a-zA-Z0-9._-){5,25}.@.(a-z){2,12}Nu är vi bara kvar med uttrycket för domänförlängning, liknar det fjärde scenariot, vi kommer att hantera vissa specifika domäntillägg. Om du vill kan du lägga till fler av dem genom att fästa dem i en cirkulär konsol och separera dem med ett '|' symbol.
Att konsolidera detta uttryck med det tidigare uttrycket ger oss vårt slutliga uttrycksvärde för validering av e-post.
^(a-zA-Z0-9._-){5,25}.@.(a-z){2,12}.(com|org|co.in|net)Slutsats
I den här handledningen lärde vi oss vad reguljära uttryck är tillsammans med syntaxen / symbolerna som används för att beteckna, konstruera ett reguljärt uttryck. Med reguljärt uttryck kan användaren matcha en sträng med ett visst mönster.
Detta är ganska användbart i situationer som kräver snabb validering av ingången, som när en användare anger sin e-postadress eller telefonnummer, regex kan användas för att snabbt validera formatet och informera användaren om problemet om användaren har angett fel format.
c ++ binärt trädimplementering
Vi lärde oss också att ta itu med olika scenarier som kan användas för en mängd olika applikationer. Vi tittade på steg för steg-processen för att skriva uttryck för matchande ord, alfabet, webbadresser, e-post-ID och till och med filtyper och tillägg.
Dessa scenarier är ganska användbara vid validering i realtid av användaringångar utan att skriva flera kodrader och därmed hjälper till att spara tid och minska komplexiteten. Dessa exempel har använts för att vägleda användaren att skapa sin egen uppsättning reguljära uttryck och därmed hjälpa dem att hantera flera andra olika scenarier.
Regex kan vara enkelt som att använda alfabetet eller siffror för att matcha med en given serie tecken eller komplex genom att använda en kombination av specialtecken, kvantifierare, teckenklasser etc. för att validera komplexa format eller leta efter ett specifikt mönster i karaktärsserien.
I ett nötskal är ett reguljärt uttryck ett ganska kraftfullt verktyg för en programmerare och hjälper till att minska mängden kod som krävs för att göra en datamatchning eller en valideringsuppgift.
=> Kontrollera ALLA C # -handledning här.
Rekommenderad läsning
- C # Stränghandledning - Strängmetoder med kodexempel
- C # slumpmässigt nummer och C # slumpmässig stränggenerator med kodexempel
- C ++ regex Handledning: Regelbundna uttryck i C ++ med exempel
- MongoDB Regular Expression $ regex med exempel
- Java Regex-handledning med exempel på reguljära uttryck
- Hur man använder Unix Regular Expressions
- Använda postprocessor i JMeter (Regular Expression Extractor)
- Java String Tutorial | Java-strängmetoder med exempel