C# Regex გაკვეთილი: რა არის C# რეგულარული გამოხატულება

Regex კლასი C#-ში

C# Regex-ის ეს გაკვეთილი განმარტავს რა არის რეგულარული გამოხატულება C#-ში, მისი სინტაქსი, Regex კლასის მეთოდები და როგორ გამოვიყენოთ ეს მეთოდები მაგალითების დახმარებით:

რეგულარული გამოხატულება C#-ში გამოიყენება სიმბოლოების კონკრეტული ნიმუშის შესატყვისად. რეგულარული გამონათქვამები გამოიყენება ყოველთვის, როდესაც მომხმარებელმა უნდა მოიძიოს განმეორებადი ნიმუში, გააკეთოს მონაცემთა დადასტურება, ან თუნდაც მონაცემთა ფორმატირების შესამოწმებლად.

RegEx გამოიყენება იმის დასადგენად, შეიცავს თუ არა სტრიქონი მოცემულ სიმბოლოს. რეგექსი, უპირველეს ყოვლისა, სიმბოლოების თანმიმდევრობაა, რომელიც აღნიშნავს შაბლონს.

ნიმუში შეიძლება იყოს ნებისმიერი, დაწყებული რიცხვებიდან, სიმბოლოებიდან ან ყველაფრის კომბინაციით. Regex ფართოდ გამოიყენება ვალიდაციისთვის. სტრიქონების გაანალიზება ან შესატყვისი, მაგალითად, იმის პოვნა, შეესაბამება თუ არა სტრიქონი ვალუტის ფორმატს, ტელეფონის ნომერს ან თარიღის ფორმატს.

Regex კლასი C#-ში

Regex კლასი გამოიყენება C#-ში რეგექსის ოპერაციების შესასრულებლად. ის შეიცავს რამდენიმე განსხვავებულ მეთოდს, რომლებიც შეიძლება გამოყენებულ იქნას რეგექსთან დაკავშირებული სხვადასხვა ოპერაციების შესასრულებლად.

ის შეიძლება გამოყენებულ იქნას დიდი ტექსტის გასაანალიზებლად კონკრეტული სიმბოლოების თანმიმდევრობის მოსაძებნად, მეთოდების გამოყენებით, რომლებიც შეიძლება გამოყენებულ იქნას შესასრულებლად, რათა ჩანაცვლება ან შეიძლება გამოყენებულ იქნას სიმბოლოების თანმიმდევრობის გასაყოფად.

regex კლასი იმყოფება სახელთა სივრცეში; System.Text.RegularExpression. კლასი პარამეტრად იღებს სტრიქონს სიმბოლოების თანმიმდევრობის სახით.

C# Regex Methods

რომ ჩვენ შევქმენით „^Super“ შეიძლება ემთხვეოდეს სუპერის ყველა მნიშვნელობას, თუნდაც სუპერმენის ან ზებუნებრივის, მაგრამ ჩვენ არ გვინდა მხოლოდ სიტყვა „სუპერ“.

ეს ნიშნავს, რომ სიტყვის შემდეგ უნდა იყოს თეთრი სივრცე. მონიშნეთ სიტყვის დასასრული და სხვა სიტყვის დასაწყისი. ამისათვის ჩვენ დავამატებთ სიმბოლოს „\s“ შაბლონს და ამით ვაკეთებთ ჩვენს საბოლოო შაბლონს, როგორც

^Super\s

სცენარი 3: გამოიყენეთ რეგულარული გამოხატულება სწორი ფაილის მოსაძებნად. სახელები სურათის ფაილის ტიპის გაფართოებით.

კიდევ ერთი მნიშვნელოვანი რეალურ დროში სცენარი, რომელსაც ხშირად აწყდებიან დეველოპერები, არის ფაილის ტიპების დადასტურება. ვთქვათ, ჩვენ გვაქვს ატვირთვის ღილაკი ინტერფეისში, რომელსაც შეუძლია მიიღოს მხოლოდ სურათის ფაილის ტიპის გაფართოებები.

ჩვენ უნდა დავამტკიცოთ მომხმარებლის ატვირთვის ფაილი და შევატყობინოთ მას, თუ მან არასწორი ფაილის ფორმატი ატვირთა. ამის მარტივად მიღწევა შესაძლებელია რეგულარული გამოხატვის გამოყენებით.

ქვემოთ მოცემულია მარტივი პროგრამა ამის შესამოწმებლად.

public static void Main(string[] args) gif)$"; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch("abc.jpg")); Console.WriteLine(reg.IsMatch("ab_c.gif")); Console.WriteLine(reg.IsMatch("abc123.png")); //When pattern doesnt match Console.WriteLine(reg.IsMatch(".jpg")); Console.WriteLine(reg.IsMatch("ask.jpegj"));

გამომავალი

True

მართალია

მართალი

მცდარი

მცდარია

ახსნა

აქ ჩვენ უნდა დავამთხვიოთ ფაილის სახელი. სწორი ფაილის სახელი შედგება სამი ნაწილისგან ( ფაილის სახელი + . + ფაილის გაფართოება ). ჩვენ უნდა შევქმნათ რეგულარული გამოხატულება, რომელიც ემთხვევა სამივე ნაწილს. დავიწყოთ პირველი ნაწილის, ანუ ფაილის სახელის შესაბამისობით. ფაილის სახელი შეიძლება შეიცავდეს ალფანუმერულ და სპეციალურ სიმბოლოებს.

როგორც ადრე განვიხილეთ, სიმბოლო არის „\w“. ასევე, ფაილის სახელი შეიძლება იყოს ერთი ან მეტიმოჰყვება წერტილი (.) შემდეგ ვებსაიტის სახელი, ამის შემდეგ წერტილი (.) და ბოლოს დომენის გაფართოება.

ასე რომ, წინა სცენარის მსგავსად, ჩვენ შევეცდებით მის დამთხვევას ნაწილ-ნაწილ. . ჯერ დავიწყოთ „www“-ის შესატყვისით. ნაწილი. ასე რომ, ჩვენ ვიწყებთ საწყისი სიმბოლოთი, შემდეგ "www". ეს არის რაღაც დაფიქსირებული, ამიტომ ვიყენებთ საწყის სიმბოლოს, რასაც მოჰყვება ზუსტი სიტყვები.

“^www.”

შემდეგ დავიწყებთ მეორე ნაწილზე მუშაობას. ვებ მისამართის მეორე ნაწილი შეიძლება იყოს ნებისმიერი ალფანუმერული სახელი. ასე რომ, აქ ჩვენ გამოვიყენებთ კვადრატულ ფრჩხილებს სიმბოლოების კლასში, რათა განვსაზღვროთ დიაპაზონი, რომელიც უნდა შეესაბამებოდეს. მეორე ნაწილის მეორე ნაწილთან დამატების შემდეგ მოგვცემს.

“^www.[a-zA-Z0-9]{3,20}”

აქ ასევე დავამატეთ ხვეული ბრეკეტები, რათა განვსაზღვროთ სიმბოლოების მინიმალური და მაქსიმალური სიგრძე ვებსაიტის სახელისთვის. ჩვენ მივეცით მინიმუმ 3 და მაქსიმუმ 20. თქვენ შეგიძლიათ მიუთითოთ თქვენთვის სასურველი მინიმალური ან მაქსიმალური სიგრძე.

ახლა, ვებ-მისამართის პირველი და მეორე ნაწილების გაშუქების შემდეგ, ჩვენ მხოლოდ ბოლო გვრჩება. ნაწილი, ანუ დომენის გაფართოება. ეს საკმაოდ ჰგავს იმას, რაც გავაკეთეთ ბოლო სცენარში, ჩვენ პირდაპირ დავამთხვევთ დომენის გაფართოებებს OR-ის გამოყენებით და ყველა მოქმედი დომენის გაფართოების ჩასმა წრიულ ფრჩხილში.

ამგვარად, თუ ამ ყველაფერს ერთად დავამატებთ, გვექნება. სრული რეგულარული გამოთქმა, რომელიც ემთხვევა ნებისმიერ მოქმედ ვებ მისამართს.

www.[a-zA-Z0-9]{3,20}.(com|in|org|co\.in|net|dev)$

სცენარში 5: გამოიყენეთ რეგულარული გამოხატვა ვალიდაციისთვისელფოსტის იდენტიფიკატორის ფორმატი

ვუშვათ, რომ ჩვენს ვებ გვერდზე გვაქვს შესვლის ფორმა, რომელიც მომხმარებლებს სთხოვს შეიყვანონ ელფოსტის მისამართი. გასაგები მიზეზების გამო, ჩვენ არ გვინდა, რომ ჩვენი ფორმა კვლავ გაგრძელდეს არასწორი ელფოსტის მისამართებით. მომხმარებლის მიერ შეყვანილი ელ.ფოსტის მისამართის დასადასტურებლად სწორია თუ არა, ჩვენ შეგვიძლია გამოვიყენოთ რეგულარული გამოხატულება.

ქვემოთ მოცემულია მარტივი პროგრამა ელფოსტის მისამართის დასადასტურებლად.

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("[email protected]")); Console.WriteLine(reg.IsMatch("[email protected]")); //When pattern doesnt match Console.WriteLine(reg.IsMatch("[email protected]")); }

გამომავალი

მართალი

მცდარი

ახსნა

A მოქმედი ელფოსტის მისამართი შეიცავს ანბანებს, ციფრებს და ზოგიერთ სპეციალურ სიმბოლოს, როგორიცაა წერტილი (.), ტირე (-) და ქვედა ხაზები (_), რასაც მოჰყვება „@“ სიმბოლო, რომელსაც მოჰყვება დომენის სახელი და დომენის გაფართოება.

ამგვარად, ჩვენ შეგვიძლია დავყოთ ელ.ფოსტის მისამართი ოთხ ნაწილად, ანუ ელ.ფოსტის იდენტიფიკატორი, "@" სიმბოლო, დომენის სახელი და ბოლო არის დომენის გაფართოება.

დავიწყოთ რეგულარული გამოხატვის დაწერით პირველი ნაწილი. ეს შეიძლება იყოს ალფა-ციფრული რამდენიმე სპეციალური სიმბოლოთი. დავუშვათ, რომ ჩვენ გვაქვს გამოხატვის ზომა 5-დან 25 სიმბოლომდე. ისევე, როგორც ადრე დავწერეთ (ელფოსტის სცენარში), შეგვიძლია გამოვიტანოთ შემდეგი გამოთქმა.

^[a-zA-Z0-9\._-]{5,25}

ახლა გადავიდეთ მეორე ნაწილზე. ეს შედარებით მარტივია, რადგან მხოლოდ ერთი სიმბოლო უნდა დავამთხვიოთ, ანუ "@". ზემოაღნიშნულ გამოთქმაში მისი დამატება გვაძლევს.

^[a-zA-Z0-9\._-]{5,25}.@

მესამე ნაწილზე გადასვლა, ანუ დომენის სახელი ყოველთვის იქნება ქვედა რიგის სერია.შესატყვისი სიტყვები, ანბანები, ვებსაიტების მისამართები, ელ.ფოსტის იდენტიფიკატორი და ფაილის ტიპები და გაფართოებებიც კი.

ეს სცენარები საკმაოდ გამოსადეგია მომხმარებლის შეყვანის რეალურ დროში ვალიდაციისთვის, კოდის მრავალი სტრიქონის დაწერის გარეშე და ამით გვეხმარება დროისა და დროის დაზოგვაში. შეამციროს სირთულე. ეს მაგალითები გამოყენებული იქნა მომხმარებლისთვის, რათა შექმნას საკუთარი რეგულარული გამონათქვამები და ამგვარად დაეხმაროს მას რამდენიმე სხვა სხვადასხვა სცენარის დამუშავებაში.

Regex შეიძლება იყოს მარტივი ანბანის ან ციფრების გამოყენება მოცემულ სერიასთან შესატყვისად. სიმბოლოები ან კომპლექსი სპეციალური სიმბოლოების, რაოდენობების, სიმბოლოების კლასების და ა.შ. კომბინაციის გამოყენებით რთული ფორმატების დასადასტურებლად ან სიმბოლოების სერიაში კონკრეტული ნიმუშის მოსაძებნად.

მოკლედ, რეგულარული გამოხატულება საკმაოდ მარტივია. მძლავრი ინსტრუმენტი პროგრამისტისთვის და ეხმარება შეამციროს კოდის რაოდენობა, რომელიც საჭიროა მონაცემთა შესატყვისი ან ვალიდაციის დავალების შესასრულებლად.

IsMatch

Regex კლასში ყველაზე მარტივი და სასარგებლო მეთოდია IsMatch მეთოდი. ამ მეთოდს აქვს სხვადასხვა გადატვირთვა სხვადასხვა პარამეტრებზე დაფუძნებული სიმბოლოების შესასრულებლად.

უმარტივესი არის

Replace (სტრიქონის ტექსტი, სტრიქონის ჩანაცვლების ტექსტი)

ჩანაცვლების მეთოდი იღებს ორს. პარამეტრებს და აბრუნებს სტრიქონის მნიშვნელობას. პირველი პარამეტრი არის სიმბოლოების თანმიმდევრობა ან რეგექსი, რომელიც გსურთ გამოიყენოთ შესატყვისად და მეორე არის რეგექსის ჩანაცვლება.

მეთოდი მუშაობს მოცემული ტექსტის შესატყვისის პოვნის გზით და შემდეგ ცვლის მას მომხმარებლის მიერ მოწოდებული ჩანაცვლების ტექსტი. მეთოდის ხელმოწერა არის public string Replace(string text, string replacementText)

Public string[] Split(string text)

Split მეთოდი regex კლასიდან იღებს სტრიქონების შეყვანას პარამეტრად და აბრუნებს ქვესტრიქონების შემცველ მასივს. მეთოდში გადაცემული პარამეტრი არის სტრიქონი, რომელიც უნდა გაიყოს.

მეთოდი პოულობს შესატყვისი შეყვანის შაბლონს სტრიქონში და როგორც კი გამოავლენს რომელიმე შესატყვის შაბლონს, ის ყოფს სტრიქონს ამ ადგილას უფრო პატარა ქვესტრინგად თითოეული შესატყვისი ნიმუში არის რღვევის წერტილი. შემდეგ მეთოდი აბრუნებს მასივს, რომელიც შეიცავს ყველა ქვესტრიქონს.

Regex C# მეთოდების გამოყენება

მოდით, გადავხედოთ ამ მეთოდების გამოყენებას მარტივი პროგრამის დაწერით.

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); } }

ზემოაღნიშნულის გამომავალიპროგრამა

True

Replace World

Hello

World

დღეს

ზემოხსენებული კოდის ახსნა:

პროგრამის დასაწყისში ჩვენ შევქმენით ობიექტი და ნიმუში, რომელსაც გამოვიყენებთ კოდის შესატყვისი სტრიქონის შემდგომ შეყვანაში, ჩვენ გამოვიყენეთ ტექსტის ფორმატირება, რათა თავიდანვე მარტივი შევინარჩუნოთ, მაგრამ თუ კომფორტულად გრძნობთ თავს, შეგიძლიათ დაიწყოთ რეგულარული გამოხატვის შაბლონების გამოყენება. (ამ სახელმძღვანელოში წინსვლისას ჩვენ დეტალურად განვიხილავთ რეგულარული გამოხატვის შაბლონს)

შემდეგ, გამოვიყენებთ შესატყვის სტრიქონს, რათა შეიყვანოთ ის ფაქტორი, რომელიც ჩვენ გამოვაცხადეთ მითითებულ ობიექტად შეყვანის სტრიქონთან და თუ ემთხვევა შემდეგ ის დაუბრუნდება false-ს.

შემდეგი მეთოდი, რომელიც ჩვენ გამოვიყენეთ არის IsMethod(string input, int index). ეს მეთოდი იღებს ორ პარამეტრს და აქ ჩვენ ვაძლევთ შეყვანის სტრიქონს და ინდექსს, საიდანაც მატჩი უნდა დაიწყოს. მაგალითად, აქ გვინდოდა დაწყებულიყო შესატყვისი შეყვანის სტრიქონის დასაწყისიდან.

შემდეგ ჩვენ ვაჩვენეთ IsMatch-ის გამოყენება (სტრიქონის შეყვანა, სტრიქონის ნიმუში). აქ ჩვენ მივაწოდეთ შეყვანის სტრიქონი, შემდეგ გვინდოდა გაგვეგო, არის თუ არა ნიმუშის ტექსტი შეყვანაში. თუ ის აწმყო, მაშინ ის დააბრუნებს true (როგორც ჩვენს შემთხვევაში), წინააღმდეგ შემთხვევაში ის დაბრუნდება false.

სხვა მეთოდი, რომელიც განვიხილეთ, ჩანაცვლებულია. ეს მეთოდი საკმაოდ გამოსადეგია პროგრამებში, სადაც გსურთ ცვლილებების შეტანა შეყვანის მონაცემებშიან შეცვალეთ არსებული მონაცემების ფორმატი.

აქ ჩვენ გთავაზობთ ორ პარამეტრს, პირველი არის შეყვანის სტრიქონი და მეორე არის სტრიქონი, რომელიც შეიძლება გამოყენებულ იქნას წინა სტრიქონის ჩანაცვლებისთვის. ეს მეთოდი ასევე იყენებს რეგექსის ობიექტში განსაზღვრულ შაბლონს, რომელიც ადრე განვსაზღვრეთ.

კიდევ ერთი მნიშვნელოვანი მეთოდი, რომელიც ჩვენ გამოვიყენეთ, არის გაყოფა. ეს მეთოდი გამოიყენება მოცემული სტრიქონის გასაყოფად რამდენიმე განმეორებადი შაბლონის საფუძველზე. აქ ჩვენ მივაწოდეთ სტრიქონი "Hello_World_Today".

ვთქვათ, რომ გვინდა ამოვიღოთ ქვედა ხაზი მოცემული სტრიქონიდან და მივიღოთ ქვესტრიქონები. ამისათვის ჩვენ ვაზუსტებთ შეყვანის პარამეტრს და შემდეგ ვაძლევთ შაბლონს, რომელიც უნდა გამოვიყენოთ როგორც გამყოფი წერტილი. მეთოდი აბრუნებს მასივს და ჩვენ შეგვიძლია გამოვიყენოთ მარტივი ციკლი, როგორიცაა foreach ყველა სტრიქონის მოსაძიებლად.

რეგულარული გამოხატვის სინტაქსი

არსებობს რამდენიმე განსხვავებული სინტაქსი, როგორიცაა სპეციალური სიმბოლოები, რაოდენობები, სიმბოლოების კლასები, და ა.შ., რომელიც შეიძლება გამოყენებულ იქნას მოცემული შეყვანიდან გარკვეული ნიმუშის შესატყვისად.

გაკვეთილის ამ ნაწილში ჩვენ ღრმად ჩავუღრმავდებით სინტაქსს, რომელსაც გთავაზობთ regex და შევეცდებით გადავჭრათ რეალური ცხოვრებისეული სცენარი. მათი გამოყენებით. სანამ გავაგრძელებთ, დარწმუნდით, რომ გაიგეთ რეგექსის ძირითადი იდეა და რეგექსის კლასში არსებული სხვადასხვა მეთოდები.

სპეციალური სიმბოლოები

რეგექსის სპეციალური სიმბოლოები გამოიყენება რამდენიმე განსხვავებული მნიშვნელობის მინიჭებისთვის. ნიმუშისკენ. ჩვენ ახლა გადავხედავთზოგიერთი ფართოდ გამოყენებული სპეციალური სიმბოლო და მათი მნიშვნელობა Regex.3

სპეციალური სიმბოლოები	მნიშვნელობა
^	ეს არის ერთ-ერთი ყველაზე ფართოდ გამოყენებული სინტაქსი. იგი აღნიშნავს დასაწყისს, სიტყვას ან შაბლონს ამის შემდეგ დაიწყებს თანხვედრას შეყვანის ტექსტის დასაწყისიდან.
$	ეს ნიშანი გამოიყენება ბოლოდან სიტყვების შესატყვისად. სიმების. ამ სიმბოლოს წინ აღნიშული სიტყვები/ნიმუშები ემთხვევა სტრიქონის ბოლოში არსებულ სიტყვებს.
. (წერტილი)	წერტილი გამოიყენება მოცემულ სტრიქონში ერთი სიმბოლოს შესატყვისად, რომელიც ხდება ერთხელ.
\n	ეს გამოიყენება ახალი ხაზი.
\d და \D	პატარა „d“ გამოიყენება ციფრული სიმბოლოს შესატყვისად, ხოლო დიდი „D“ გამოიყენება არაციფრის შესატყვისად. სიმბოლოები.
\s და \S	პატარა "s" გამოიყენება თეთრი სივრცეების შესატყვისად, ხოლო ზედა "S" გამოიყენება არათეთრი სივრცის შესატყვისად. .
\w და \W	პატარა „w“ გამოიყენება ალფანუმერული/ხაზგასმული სიმბოლოების შესატყვისად, ხოლო დიდი „W“ გამოიყენება არასიტყვის შესატყვისად. სიმბოლოები.

Quantifier Syntax

Quantifier syntax გამოიყენება შესატყვისი კრიტერიუმების დასათვლელად ან რაოდენობრივად. მაგალითად, თუ გსურთ შეამოწმოთ, შეიცავს თუ არა კონკრეტული სტრიქონი ანბანს ერთხელ ან მეტჯერ. მოდით გადავხედოთ ზოგიერთ ჩვეულებრივ გამოყენებად კვანტიფიკატორს რეგულარულ გამოხატულებაში.

Quantifierსინტაქსი	მნიშვნელობა
*	ეს სიმბოლო გამოიყენება წინა სიმბოლოსთან შესატყვისად.
+	ეს სიმბოლო გამოიყენება ზედიზედ ერთი ან მეტი სიმბოლოს შესატყვისად.
{n}	ციფრული ციფრი ხვეულის შიგნით ფრჩხილები გამოიყენება წინა სიმბოლოს რიცხვის შესატყვისად, რომელიც განსაზღვრულია ციფრული ფრჩხილი ბრეკეტების შიგნით.
{n,}	ციფრი ხვეული ბრეკეტებში და ეს სიმბოლო გამოიყენება. რათა დავრწმუნდეთ, რომ ის ემთხვევა მინიმუმ n-ს (ანუ ციფრულ მნიშვნელობას ფრჩხილებში).
{n, m}	ეს სიმბოლო გამოიყენება წინა სიმბოლოდან შესატყვისად n-ჯერ რიცხვი m-ის რაოდენობამდე.
?	ეს სიმბოლო წინა სიმბოლოებს არჩევით ახასიათებს.

პერსონაჟების კლასი

გმირების კლასი ასევე ცნობილია, როგორც სიმბოლოების ნაკრები და ეს გამოიყენება რეგექსის ძრავის სათქმელად, მოძებნოს ერთი შესატყვისი რამდენიმე სიმბოლოდან. სიმბოლოთა კლასი დაემთხვევა მხოლოდ ერთ სიმბოლოს და სიმბოლოების თანმიმდევრობას არ აქვს მნიშვნელობა.

პერსონაჟების კლასი	მნიშვნელობა
[ დიაპაზონი ]	კვადრატული ფრჩხილის სიმბოლო გამოიყენება სიმბოლოთა დიაპაზონის შესატყვისად. მაგალითად, ჩვენ შეგვიძლია გამოვიყენოთ ის, რომ განვსაზღვროთ ნებისმიერი სიმბოლო დიაპაზონში ანბანიდან „a“-დან „z“-მდე, ფრჩხილის შიგნით დიაპაზონის ჩასმით, როგორიცაა [a-z] ან, ასევე შეგვიძლია დავამთხვიოთ რიცხვითი „1“-ს „ 9” აღსანიშნავადგამონათქვამები რეალურ დროში რამდენიმე მაგალითის გამოყენებით. სცენარი 1: გადამოწმება, თუ შეყვანის სტრიქონი შედგება 6 ციფრიანი ასოების ასოებით, რომლებიც არ არის მგრძნობიარე ასოები. რეგულარული გამოხატვის ყველაზე გავრცელებული სცენარი არის მოცემული სიტყვის პოვნა და შესატყვისი. მაგალითად, ვთქვათ, მე მინდა მომხმარებლისგან შემთხვევითი ანბანური სტრიქონი და ეს შეყვანა უნდა იყოს ზუსტად 6 ციფრიანი. დასადასტურებლად შეგვიძლია გამოვიყენოთ მარტივი რეგულარული გამოხატულება. მოდით დავწეროთ პროგრამა, რათა უკეთ გავიგოთ რეგულარული გამოხატვის ჩაწერა და გამოყენება. 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")); } გამომავალი True False ახსნა ამ მაგალითში ჩვენ ვცდილობთ შევამოწმოთ შეყვანის სტრიქონი, რათა შევამოწმოთ შეიცავს თუ არა ის ექვსნიშნა ანბანურ სიმბოლოებს. სიმბოლოები შეიძლება იყოს როგორც ქვედა, ასევე დიდი ასოებით, ამიტომ ჩვენ ესეც უნდა გავითვალისწინოთ. ასე რომ, აქ განვსაზღვრეთ რეგულარული გამოხატვის ნიმუში ცვლადში "patternText" და შემდეგ გადავიტანეთ რეგექსის ობიექტში. . ახლა, კოდის შემდეგი სტრიქონები საკმაოდ მარტივია, ჩვენ გამოვიყენეთ IsMatch მეთოდი რეგულარული გამოსახულებისა და შეყვანის სტრიქონის შესადარებლად. მოდით, ახლა გადავხედოთ ჩვენს მიერ შემუშავებულ რეგულარულ გამოსახულებას. გამოთქმა (^[a-zA-Z]{6}$) შედგება 4 სხვადასხვა ნაწილისგან. "^", "[a-zA-Z]", "{6}" და "$". მეორე ნაწილი აღნიშნავს შესატყვის სიმბოლოებს, რომლებიც გამოიყენება გამოხატვის შესატყვისად, "a-z" მცირე რეგისტრისთვის და "A-Z" დიდი ასოებისთვის. პირველი.ნაწილის სიმბოლო „^“ უზრუნველყოფს, რომ სტრიქონი იწყება მეორე ნაწილში განსაზღვრული ნიმუშით, ანუ ქვედა და ზედა ასოებით. მესამე ნაწილში ხვეული ბრეკეტები განსაზღვრავს სიმბოლოების რაოდენობას სტრიქონში, რომელთა იდენტიფიცირებაც შესაძლებელია. განსაზღვრული ნიმუშით, ანუ 6 ამ შემთხვევაში და "$" სიმბოლოთი დარწმუნდით, რომ ის მთავრდება მეორე ნაწილში განსაზღვრული ნიმუშით. ^[a-zA-Z]{6}$ სცენარი 2: გამოიყენეთ რეგულარული გამოთქმა, რათა დაადასტუროთ სიტყვა, რომელიც იწყება „სუპერ“-ით და აქვს თეთრი სივრცე ამის შემდეგ, ანუ იმის დასადასტურებლად, არის თუ არა „სუპერ“ წინადადების დასაწყისში. დავუშვათ, რომ ჩვენ ვკითხულობთ მომხმარებლის გარკვეულ შეყვანას და უნდა დავრწმუნდეთ, რომ მომხმარებელი ყოველთვის იწყებს თავის წინადადებას კონკრეტული სიტყვით, რიცხვით ან ანბანით. ამის მიღწევა საკმაოდ მარტივად შეიძლება მარტივი რეგულარული გამონათქვამის გამოყენებით. მოდით, გადავხედოთ პროგრამის ნიმუშს და შემდეგ დეტალურად განვიხილოთ, თუ როგორ უნდა დაწეროთ ეს გამონათქვამი. public static void Main(string[] args) { string patternText = @"^Super\s"; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch("Super man")); //When pattern doesnt match Console.WriteLine(reg.IsMatch("Superhero")); } გამომავალი მართალია მცდარი ახსნა ამ მაგალითშიც, ჩვენ გამოვიყენეთ კოდის მსგავსი დაყენება, როგორც ეს გავაკეთეთ პირველი. რეგულარული გამოხატვის ნიმუში ამ სცენარში მოითხოვს სიტყვების ან წინადადებების კომბინაციას, რომლებიც იწყება „სუპერ“-ით. ^Super ასე რომ, როგორც ჩვენ გვინდა, რომ შეესაბამებოდეს სიტყვის დასაწყისიდან. სერია, ჩვენ დავიწყებთ „^“ სიმბოლოს დაყენებით, შემდეგ მივცემთ იმ შაბლონს, რომლის შესატყვისი გვინდა, ამ შემთხვევაში, „Super“. ახლა ნიმუში[1-9]
[^ დიაპაზონი]	ეს აღნიშნავს სიმბოლოების უარყოფის კლასს. იგი გამოიყენება რაიმეს შესატყვისად და არა ფრჩხილის შიგნით აღნიშნულ დიაპაზონში.
\	ეს გამოიყენება სპეციალური სიმბოლოების შესატყვისად, რომლებსაც შეიძლება ჰქონდეთ საკუთარი რეგექსის სიმბოლოები. ხაზგასმა გამოიყენება სპეციალური სიმბოლოების მათი პირდაპირი ფორმით შესატყვისად.

პერსონაჟების კლასი

მნიშვნელობა

[ დიაპაზონი ]

კვადრატული ფრჩხილის სიმბოლო გამოიყენება სიმბოლოთა დიაპაზონის შესატყვისად. მაგალითად, ჩვენ შეგვიძლია გამოვიყენოთ ის, რომ განვსაზღვროთ ნებისმიერი სიმბოლო დიაპაზონში ანბანიდან „a“-დან „z“-მდე, ფრჩხილის შიგნით დიაპაზონის ჩასმით, როგორიცაა [a-z]

ან, ასევე შეგვიძლია დავამთხვიოთ რიცხვითი „1“-ს „ 9” აღსანიშნავადგამონათქვამები რეალურ დროში რამდენიმე მაგალითის გამოყენებით.

სცენარი 1: გადამოწმება, თუ შეყვანის სტრიქონი შედგება 6 ციფრიანი ასოების ასოებით, რომლებიც არ არის მგრძნობიარე ასოები.

რეგულარული გამოხატვის ყველაზე გავრცელებული სცენარი არის მოცემული სიტყვის პოვნა და შესატყვისი. მაგალითად, ვთქვათ, მე მინდა მომხმარებლისგან შემთხვევითი ანბანური სტრიქონი და ეს შეყვანა უნდა იყოს ზუსტად 6 ციფრიანი.

დასადასტურებლად შეგვიძლია გამოვიყენოთ მარტივი რეგულარული გამოხატულება. მოდით დავწეროთ პროგრამა, რათა უკეთ გავიგოთ რეგულარული გამოხატვის ჩაწერა და გამოყენება.

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")); }

გამომავალი

True

False

ახსნა

ამ მაგალითში ჩვენ ვცდილობთ შევამოწმოთ შეყვანის სტრიქონი, რათა შევამოწმოთ შეიცავს თუ არა ის ექვსნიშნა ანბანურ სიმბოლოებს. სიმბოლოები შეიძლება იყოს როგორც ქვედა, ასევე დიდი ასოებით, ამიტომ ჩვენ ესეც უნდა გავითვალისწინოთ.

ასე რომ, აქ განვსაზღვრეთ რეგულარული გამოხატვის ნიმუში ცვლადში "patternText" და შემდეგ გადავიტანეთ რეგექსის ობიექტში. . ახლა, კოდის შემდეგი სტრიქონები საკმაოდ მარტივია, ჩვენ გამოვიყენეთ IsMatch მეთოდი რეგულარული გამოსახულებისა და შეყვანის სტრიქონის შესადარებლად.

მოდით, ახლა გადავხედოთ ჩვენს მიერ შემუშავებულ რეგულარულ გამოსახულებას. გამოთქმა (^[a-zA-Z]{6}$) შედგება 4 სხვადასხვა ნაწილისგან. "^", "[a-zA-Z]", "{6}" და "$". მეორე ნაწილი აღნიშნავს შესატყვის სიმბოლოებს, რომლებიც გამოიყენება გამოხატვის შესატყვისად, "a-z" მცირე რეგისტრისთვის და "A-Z" დიდი ასოებისთვის.

პირველი.ნაწილის სიმბოლო „^“ უზრუნველყოფს, რომ სტრიქონი იწყება მეორე ნაწილში განსაზღვრული ნიმუშით, ანუ ქვედა და ზედა ასოებით.

მესამე ნაწილში ხვეული ბრეკეტები განსაზღვრავს სიმბოლოების რაოდენობას სტრიქონში, რომელთა იდენტიფიცირებაც შესაძლებელია. განსაზღვრული ნიმუშით, ანუ 6 ამ შემთხვევაში და "$" სიმბოლოთი დარწმუნდით, რომ ის მთავრდება მეორე ნაწილში განსაზღვრული ნიმუშით.

^[a-zA-Z]{6}$

სცენარი 2: გამოიყენეთ რეგულარული გამოთქმა, რათა დაადასტუროთ სიტყვა, რომელიც იწყება „სუპერ“-ით და აქვს თეთრი სივრცე ამის შემდეგ, ანუ იმის დასადასტურებლად, არის თუ არა „სუპერ“ წინადადების დასაწყისში.

დავუშვათ, რომ ჩვენ ვკითხულობთ მომხმარებლის გარკვეულ შეყვანას და უნდა დავრწმუნდეთ, რომ მომხმარებელი ყოველთვის იწყებს თავის წინადადებას კონკრეტული სიტყვით, რიცხვით ან ანბანით. ამის მიღწევა საკმაოდ მარტივად შეიძლება მარტივი რეგულარული გამონათქვამის გამოყენებით.

მოდით, გადავხედოთ პროგრამის ნიმუშს და შემდეგ დეტალურად განვიხილოთ, თუ როგორ უნდა დაწეროთ ეს გამონათქვამი.

 public static void Main(string[] args) { string patternText = @"^Super\s"; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch("Super man")); //When pattern doesnt match Console.WriteLine(reg.IsMatch("Superhero")); }

გამომავალი

მართალია

მცდარი

ახსნა

ამ მაგალითშიც, ჩვენ გამოვიყენეთ კოდის მსგავსი დაყენება, როგორც ეს გავაკეთეთ პირველი. რეგულარული გამოხატვის ნიმუში ამ სცენარში მოითხოვს სიტყვების ან წინადადებების კომბინაციას, რომლებიც იწყება „სუპერ“-ით.

^Super

ასე რომ, როგორც ჩვენ გვინდა, რომ შეესაბამებოდეს სიტყვის დასაწყისიდან. სერია, ჩვენ დავიწყებთ „^“ სიმბოლოს დაყენებით, შემდეგ მივცემთ იმ შაბლონს, რომლის შესატყვისი გვინდა, ამ შემთხვევაში, „Super“. ახლა ნიმუში[1-9]

[^ დიაპაზონი]

ეს აღნიშნავს სიმბოლოების უარყოფის კლასს. იგი გამოიყენება რაიმეს შესატყვისად და არა ფრჩხილის შიგნით აღნიშნულ დიაპაზონში.

ეს გამოიყენება სპეციალური სიმბოლოების შესატყვისად, რომლებსაც შეიძლება ჰქონდეთ საკუთარი რეგექსის სიმბოლოები. ხაზგასმა გამოიყენება სპეციალური სიმბოლოების მათი პირდაპირი ფორმით შესატყვისად.

დაჯგუფება

მრგვალი ფრჩხილები ან ფრჩხილები შეიძლება გამოყენებულ იქნას რეგულარული ნაწილის დასაჯგუფებლად. გამოხატვა ერთად. ეს საშუალებას აძლევს მომხმარებელს დაამატოს რაოდენობრივი მაჩვენებელი გამოსახულებით.

დაჯგუფება	მნიშვნელობა
( ჯგუფი გამოხატულება )	მრგვალი ფრჩხილები გამოიყენება გამოხატვის დასაჯგუფებლად.
სიმბოლოები გამოიყენებენ სიმბოლოს "+". გააერთიანეთ ისინი და მივიღებთ პირველი ნაწილის სიმბოლოს. (\w+) ბრეკეტმა ეს გამოყო ნაწილებად. შემდეგი ნაწილი არის წერტილის სიმბოლო. ვინაიდან წერტილის სიმბოლოს თავისი მნიშვნელობა აქვს რეგექსში, ჩვენ გამოვიყენებთ უკანა ხაზს მის წინ, რათა მას პირდაპირი მნიშვნელობა მივცეთ. გააერთიანეთ ორივე და ჩვენ გვაქვს რეგექსის პირველი ორი ნაწილი დაფარული. (\w+)\. ახლა, მესამე და ბოლო ნაწილისთვის, ჩვენ შეგვიძლია პირდაპირ განვსაზღვროთ ფაილის საჭირო გაფართოებები, რომლებიც გამოყოფილია "-ით.საქმე ანბანური სიმბოლოები. თუ გსურთ, შეგიძლიათ ასევე შეიყვანოთ რიცხვითი ან დიდი ანბანის სიმბოლოები, მაგრამ ამ სცენარისთვის, ჩვენ მივდივართ მცირე ასოებით. თუ დავამატებთ გამოხატულებას მცირე ასოებისთვის, რომელთა სიგრძე მერყეობს 2-დან 12 სიმბოლომდე, შემდეგ გვექნება შემდეგი გამონათქვამი. ^[a-zA-Z0-9\._-]{5,25}.@.[a-z]{2,12} ახლა, ჩვენ მხოლოდ რჩება გამოთქმა დომენის გაფართოებისთვის, მეოთხე სცენარის მსგავსი, ჩვენ დავამუშავებთ დომენის რამდენიმე კონკრეტულ გაფართოებას. თუ გსურთ, შეგიძლიათ დაამატოთ მეტი მათგანი წრიულ ფრჩხილში ჩასმით და გამოყოფით "

დაჯგუფება

მნიშვნელობა

( ჯგუფი გამოხატულება )

მრგვალი ფრჩხილები გამოიყენება გამოხატვის დასაჯგუფებლად.

სიმბოლოები გამოიყენებენ სიმბოლოს "+". გააერთიანეთ ისინი და მივიღებთ პირველი ნაწილის სიმბოლოს.

(\w+)

ბრეკეტმა ეს გამოყო ნაწილებად. შემდეგი ნაწილი არის წერტილის სიმბოლო. ვინაიდან წერტილის სიმბოლოს თავისი მნიშვნელობა აქვს რეგექსში, ჩვენ გამოვიყენებთ უკანა ხაზს მის წინ, რათა მას პირდაპირი მნიშვნელობა მივცეთ. გააერთიანეთ ორივე და ჩვენ გვაქვს რეგექსის პირველი ორი ნაწილი დაფარული.

(\w+)\.

ახლა, მესამე და ბოლო ნაწილისთვის, ჩვენ შეგვიძლია პირდაპირ განვსაზღვროთ ფაილის საჭირო გაფართოებები, რომლებიც გამოყოფილია "-ით.საქმე ანბანური სიმბოლოები. თუ გსურთ, შეგიძლიათ ასევე შეიყვანოთ რიცხვითი ან დიდი ანბანის სიმბოლოები, მაგრამ ამ სცენარისთვის, ჩვენ მივდივართ მცირე ასოებით.

თუ დავამატებთ გამოხატულებას მცირე ასოებისთვის, რომელთა სიგრძე მერყეობს 2-დან 12 სიმბოლომდე, შემდეგ გვექნება შემდეგი გამონათქვამი.

^[a-zA-Z0-9\._-]{5,25}.@.[a-z]{2,12}

ახლა, ჩვენ მხოლოდ რჩება გამოთქმა დომენის გაფართოებისთვის, მეოთხე სცენარის მსგავსი, ჩვენ დავამუშავებთ დომენის რამდენიმე კონკრეტულ გაფართოებას. თუ გსურთ, შეგიძლიათ დაამატოთ მეტი მათგანი წრიულ ფრჩხილში ჩასმით და გამოყოფით "