რეგულარული გამონათქვამები JavaScript– ში. RegExp ობიექტი

JavaScript– ში RegExp კლასი არის რეგულარული გამოთქმა - ობიექტი, რომელიც აღწერს პერსონაჟის ნიმუშს. RegExp ობიექტები ჩვეულებრივ იქმნება ქვემოთ მოცემული სპეციალური ლიტერატურული სინტაქსის გამოყენებით, მაგრამ ისინი ასევე შეიძლება შეიქმნას RegExp () კონსტრუქტორის გამოყენებით.

Სინტაქსი

პარამეტრების მნიშვნელობები:

რეგულარული გამოხატვის დროშები

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

მეტაკარტატები

შეზღუდვები

რაოდენობრივი

დაჯგუფება და ბმულები

ეს სტატია მოიცავს Javascript– ში რეგულარული გამოხატვის გამოყენების საფუძვლებს.

შესავალი

რა არის რეგულარული გამოთქმა?

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

Javascript– ში რეგულარული გამონათქვამები ასევე არის ობიექტები. ეს არის ნიმუშები, რომლებიც გამოიყენება სიმბოლოების თანმიმდევრობით სტრიქონებში. ისინი გამოიყენება RegExp ობიექტის exec () და test () მეთოდებში, ასევე სიმებიანი ობიექტის დამთხვევის (), ჩანაცვლების (), ძიებისა და გაყოფის () მეთოდებში.

მაგალითი

var ნიმუში = / მაგალითი / i

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

რეგულარული გამოთქმის მომზადება

JS რეგულარული გამონათქვამები შედგება ნიმუშისა და მოდიფიკატორისგან. სინტაქსი იქნება ასეთი:

/ pattern / modifiers;

შაბლონი განსაზღვრავს ძებნის წესს. იგი შედგება მარტივი სიმბოლოებისგან, როგორიცაა / abc / ან მარტივი და სპეციალური პერსონაჟები: / abc / ან / თავი (d +). d /.

შაბლონის ცხრილი

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

მოდიფიკაციის ცხრილი

ჩვენ ახლა მზად ვართ გამოვიყენოთ JS რეგულარული გამონათქვამები. ამის გაკეთების ორი ძირითადი გზა არსებობს: regex ობიექტის გამოყენება ან regex სიმებისათვის.

რეგექსის ობიექტის გამოყენება

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

ეს ობიექტი აღწერს პერსონაჟის ნიმუშს. იგი გამოიყენება ნიმუშების შესატყვისად. რეგულარული გამოხატვის ობიექტის აგების ორი გზა არსებობს.

მეთოდი 1: რეგექს ლიტერატურის გამოყენება, რომელიც შედგება შაბლონში ჩასმული შაბლონისგან, მაგალითად:

var reg = / ab + c /;

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

მეთოდი 2: RegExp ობიექტის კონსტრუქტორის ფუნქციის გამოძახებით, მაგალითად:

var reg = ახალი RegExp ("ab + c");

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

რეგულარული გამოხატვის ობიექტის მეთოდები

მოდით შევხედოთ რეგულარული გამოხატვის ობიექტის რამდენიმე ჩვეულებრივ მეთოდს:

• შედგენა () ( მოძველებულია 1.5 ვერსიაში) - ადგენს რეგულარულ გამოთქმას;
• exec () - ასრულებს შესატყვისს სტრიქონზე. აბრუნებს პირველ მატჩს;
• ტესტი () - ასრულებს შესატყვისს სტრიქონზე. აბრუნებს ჭეშმარიტს ან მცდარს;
• toString () - აბრუნებს რეგულარული გამოხატვის სიმებიანი მნიშვნელობას.

მაგალითები

ტესტის გამოყენება ()

ტესტი () მეთოდი არის RegExp ობიექტის რეგულარული გამოხატულება. ის ეძებს შაბლონის სტრიქონს და შედეგიდან გამომდინარე, რომ ბრუნდება, ბრუნდება ჭეშმარიტი ან მცდარი. შემდეგი JS რეგულარული გამოხატვის მაგალითი გვიჩვენებს, თუ როგორ უნდა მოძებნოთ სტრიქონი პერსონაჟისათვის ” ე”:

var patt = / e /; patt.test ("მსოფლიოს საუკეთესო ნივთები უფასოა!");

რადგან აქ ხაზი შეიცავს " ე”, ამ კოდის შედეგი იქნება ჭეშმარიტი.

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

/e/.test(" მსოფლიოს საუკეთესო ნივთები უფასოა! ");

Exec () - ის გამოყენებით

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

მოდით ვნახოთ მეთოდი მოქმედებაში, იგივე სიმბოლოს მაგალითის გამოყენებით ” ე”:

/e/.exec(" მსოფლიოს საუკეთესო ნივთები უფასოა! ");

რადგან ხაზი შეიცავს " ე”, ამ კოდის შედეგი იქნება .e.

სტრიქონზე რეგულარული გამოთქმის გამოყენება

Javascript– ში ეს გამონათქვამები ასევე შეიძლება გამოყენებულ იქნას String ობიექტის ორი მეთოდით: ძებნა () და ჩანაცვლება (). ისინი საჭიროა ტექსტში ძიების შესასრულებლად და შესაცვლელად.

• საძიებო () მეთოდი - იყენებს გამონათქვამს შესატყვისი მოსაძებნად და აბრუნებს ინფორმაციას მატჩის ადგილის შესახებ;
• Replace () მეთოდი - აბრუნებს შეცვლილ სტრიქონს შეცვლილი შაბლონით.

მაგალითები

JS რეგულარული გამოხატვის გამოყენება შემთხვევისადმი მგრძნობიარე ძიებისათვის ფრაზისთვის ” w3 სკოლები" ხაზში:

var str = "ეწვიეთ W3Schools"; var n = str.search ( / w3 სკოლები / i);

შედეგი n არის 6.

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

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

რეგულარული გამონათქვამები

რეგულარული გამოთქმაარის ობიექტი, რომელიც აღწერს პერსონაჟის ნიმუშს. JavaScript– ში RegExp კლასი წარმოადგენს რეგულარულ გამონათქვამებს, ხოლო String და RegExp კლასის ობიექტები განსაზღვრავენ მეთოდებს, რომლებიც იყენებენ რეგულარულ გამონათქვამებს შაბლონების შესატყვისი და ტექსტის საძიებო ოპერაციების შესაცვლელად. JavaScript– ის რეგულარული გამოხატვის გრამატიკა შეიცავს Perl 5– ში გამოყენებული რეგულარული გამოთქმის სინტაქსის საკმაოდ სრულ ქვეგანყოფილებას, ასე რომ, თუ თქვენ გაქვთ Perl– ის გამოცდილება, შეგიძლიათ მარტივად აღწეროთ JavaScript პროგრამების ნიმუშები.

პერლის რეგულარული გამონათქვამების მახასიათებლები, რომლებიც არ არის მხარდაჭერილი ECMAScript– ში მოიცავს s (ერთხაზოვანი რეჟიმი) და x (გაფართოებული სინტაქსის) დროშებს; გაქცევის თანმიმდევრობა \ a, \ e, \ l, \ u, \ L, \ U, \ E, \ Q, \ A, \ Z, \ z, და \ G და სხვა გაფართოებული კონსტრუქციები დაწყებული (?.

რეგულარული გამონათქვამების განსაზღვრა

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

ვარ ნიმუში = / s $ /;

ეს ხაზი ქმნის ახალ RegExp ობიექტს და ანიჭებს მას ნიმუშის ცვლადს. ეს RegExp ობიექტი ეძებს ნებისმიერ სტრიქონს, რომელიც მთავრდება "s" სიმბოლოთი. იგივე რეგულარული გამოთქმა შეიძლება განისაზღვროს RegExp () კონსტრუქტორის გამოყენებით:

ვარ ნიმუში = ახალი RegExp ("s $");

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

რეგულარული გამონათქვამების სხვა სიმბოლოები არ არის გამიზნული მათი ზუსტი ეკვივალენტების საპოვნელად, არამედ აქვთ განსაკუთრებული მნიშვნელობა. მაგალითად, რეგულარული გამოთქმა / s $ / შეიცავს ორ სიმბოლოს. პირველი s მიუთითებს სიტყვასიტყვითი ხასიათის ძიებაზე. მეორე, $ არის სპეციალური მეტა ხასიათი, რომელიც აღნიშნავს ხაზის დასასრულს. ამრიგად, ეს რეჯექსი ემთხვევა s- ით დამთავრებულ ნებისმიერ სტრიქონს.

შემდეგი სექციები აღწერს JavaScript– ის რეგულარულ გამონათქვამებში გამოყენებულ სხვადასხვა პერსონაჟებსა და მეტა ხატებს.

ლიტერატურული პერსონაჟები

როგორც უკვე აღვნიშნეთ, რეგულარული გამონათქვამების ყველა ანბანური სიმბოლო და რიცხვი ემთხვევა საკუთარ თავს. JavaScript– ში რეგულარული გამოთქმის სინტაქსი ასევე მხარს უჭერს უნარის განსაზღვრას ზოგიერთი არა-ანბანური სიმბოლო, გაქცევის თანმიმდევრობების გამოყენებით, რომლებიც იწყება უკუსვლის სიმბოლოთი (\). მაგალითად, \ n ემთხვევა ხაზის არხის სიმბოლოს. ეს სიმბოლოები ჩამოთვლილია ქვემოთ მოცემულ ცხრილში:

ზოგიერთ პუნქტუაციის ნიშანს აქვს განსაკუთრებული მნიშვნელობა რეგულარულ გამონათქვამებში:

^ $ . * + ? = ! : | \ / () { } -

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

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

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

ცალკეული ლიტერატურული სიმბოლოები შეიძლება გაერთიანდეს პერსონაჟთა კლასებად, კვადრატულ ფრჩხილებში ჩასმით. სიმბოლოების კლასი ემთხვევა ამ კლასში შემავალ ნებისმიერ სიმბოლოს. მაშასადამე, რეგულარული გამოთქმა // ემთხვევა a, b ან c ერთ სიმბოლოს.

სიმბოლოების უარყოფილი კლასები ასევე შეიძლება განისაზღვროს, რათა შეესაბამებოდეს ნებისმიერ სიმბოლოს, გარდა ფრჩხილებში მითითებულისა. სიმბოლოების უარყოფილი კლასი ^ სიმბოლოთი არის მითითებული, როგორც პირველი სიმბოლო მარცხენა ფრჩხილის შემდეგ. რეგულარული გამოთქმა / [^ abc] / შეესაბამება ნებისმიერ სიმბოლოს, გარდა a, b ან c. პერსონაჟების კლასებში სიმბოლოების დიაპაზონის დადგენა შესაძლებელია დეფისის გამოყენებით. მოძებნეთ ლათინური ანბანის ყველა სიმბოლო მცირე ზომისშესრულებულია გამოხატვის // გამოყენებით და ლათინური სიმბოლოების ნებისმიერი ასო ან რიცხვი შეიძლება მოიძებნოს გამოხატვის // გამოყენებით.

პერსონაჟების გარკვეული კლასები განსაკუთრებით ხშირად გამოიყენება, ამიტომ JavaScript– ის რეგულარული გამოთქმის სინტაქსი მოიცავს სპეციალურ სიმბოლოებს და გაქცევის თანმიმდევრობას მათი აღსანიშნავად. მაგალითად, \ s ემთხვევა თეთრ სივრცეს, ჩანართებს და ნებისმიერი უნიკოდის თეთრი სივრცის სიმბოლოებს და \ S ემთხვევა ნებისმიერი არაიუნიკოდის თეთრი სივრცის სიმბოლოებს.

ქვემოთ მოცემულ ცხრილში მოცემულია ამ სპეციალური სიმბოლოები და სიმბოლოების კლასების სინტაქსი. (გაითვალისწინეთ, რომ ზოგიერთი ხასიათის კლასის გაქცევის თანმიმდევრობა ემთხვევა მხოლოდ ASCII სიმბოლოებს და არ არის გაფართოებული უნიკოდის სიმბოლოებთან მუშაობისთვის. თქვენ შეგიძლიათ მკაფიოდ განსაზღვროთ საკუთარი კლასებიუნიკოდის სიმბოლოები, მაგალითად, გამოთქმა / [\ u0400- \ u04FF] / ემთხვევა ნებისმიერ კირილეულ სიმბოლოს.)

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

გამეორება

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

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

შემდეგი სტრიქონები აჩვენებს რამდენიმე მაგალითს:

ვარ ნიმუში = / \ d (2,4) /; // ემთხვევა ორ -ოთხნიშნა რიცხვით შაბლონს = / \ w (3) \ d? /; // ზუსტად შეესაბამება სამი სიტყვის სიმბოლოს და ერთ სურვილისამებრ ციფრულ შაბლონს = / \ s + java \ s + /; // შეესაბამება სიტყვას "java" ერთ ან მეტ ინტერვალით // მის წინ და მის შემდეგ ნიმუში = / [^ (] * /; // ემთხვევა ნულს ან მეტ სიმბოლოს, გარდა ღია ფრჩხილისა

ფრთხილად იყავით განმეორებითი სიმბოლოების გამოყენებისას * და?. ისინი შეიძლება შეესაბამებოდეს მათ წინაშე მითითებული ნიმუშის არარსებობას და, შესაბამისად, სიმბოლოების არარსებობას. მაგალითად, რეგულარული გამოთქმა / a * / ემთხვევა სტრიქონს "bbbb", რადგან ის არ შეიცავს სიმბოლოს.

ცხრილში ჩამოთვლილი განმეორებითი სიმბოლოები შეესაბამება გამეორებების მაქსიმალურ რაოდენობას, რომელთა გამოყენება შესაძლებელია რეგულარული გამოთქმის შემდგომი ნაწილების მოსაძებნად. ჩვენ ვამბობთ, რომ ეს არის "ხარბ" გამეორება. ასევე შესაძლებელია განმეორების განხორციელება უმადური ფორმით. საკმარისია განმეორების სიმბოლოს (ან სიმბოლოების) შემდეგ მიუთითოთ კითხვის ნიშანი: ??, +?, *? ან თუნდაც (1.5)?.

მაგალითად, რეგულარული გამოთქმა / a + / ემთხვევა a ასოზე ერთ ან მეტ შემთხვევას. გამოიყენება სტრიქონზე "aaa", ის ემთხვევა სამივე ასოს. მეორეს მხრივ, გამოთქმა / a +? / ემთხვევა a ასოის ერთ ან მეტ მაგალითს და ირჩევს სიმბოლოების ყველაზე მცირე რაოდენობას. გამოიყენება იმავე ხაზზე, ეს ნიმუში ემთხვევა მხოლოდ პირველ ასო a -ს.

"საშიში" გამეორება ყოველთვის არ იძლევა მოსალოდნელ შედეგს. განვიხილოთ ნიმუში / a + b /, რომელიც ემთხვევა ერთ ან მეტ სიმბოლოს, რასაც მოჰყვება b სიმბოლო. როდესაც გამოიყენება სტრიქონზე "aaab", ის ემთხვევა მთელ სტრიქონს.

ახლა მოდით შევამოწმოთ "არა ხარბ" ვერსია / a +? B /. შეიძლება ვიფიქროთ, რომ ის უნდა ემთხვეოდეს b სიმბოლოს, რომელსაც წინ უძღვის მხოლოდ ერთი სიმბოლო a. თუ გამოიყენება ერთსა და იმავე სტრიქონზე, "aaab" სავარაუდოდ ემთხვევა სინგლს a და ბოლო b. თუმცა, სინამდვილეში მთელი სიმები ემთხვევა ამ ნიმუშს, როგორც "ხარბ" ვერსიის შემთხვევაში. საქმე იმაშია, რომ რეგულარული გამოხატვის ნიმუშის ძებნა ხორციელდება სტრიქონში პირველი პოზიციის პოვნით, საიდანაც შესატყვისი ხდება შესაძლებელი. ვინაიდან შესატყვისი შესაძლებელია სტრიქონის პირველი სიმბოლოდან, შემდგომი სიმბოლოებით დაწყებული უფრო მოკლე მატჩები არც კი განიხილება.

ალტერნატივები, დაჯგუფება და ბმულები

რეგულარული გამოთქმის გრამატიკა მოიცავს სპეციალურ სიმბოლოებს ალტერნატივების განსაზღვრისათვის, ქვემეტყველების დაჯგუფებისა და წინა ქვემეტყველების მითითებებისათვის. მილის სიმბოლო | ემსახურება ალტერნატივების გამოყოფას. მაგალითად, / ab | cd | ef / ემთხვევა სტრიქონს "ab", ან სტრიქონს "cd", ან სტრიქონს "ef" და ნიმუშს / \ d (3) | (4) / ემთხვევა სამ ციფრს ან ოთხი მცირე ასო ...

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

რეგულარულ გამოთქმებში ფრჩხილებს აქვთ რამდენიმე მნიშვნელობა. ერთ -ერთი მათგანია დაჯგუფება ინდივიდუალური ელემენტებიერთ ქვესახეობაში, ისე რომ ელემენტები სპეციალური სიმბოლოების გამოყენებისას |, *, +,? და სხვები განიხილება მთლიანად. მაგალითად, / java (სკრიპტი)? / შეესაბამება სიტყვას "java" რასაც მოყვება არჩევითი სიტყვა "script" და / (ab | cd) + | ef) / ემთხვევა სტრიქონს "ef" ან ერთ ან მეტ გამეორებას იგივე სტრიქონებიდან "ab" ან "cd".

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

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

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

/ (ava (cript)?) \ sis \ s (გართობა \ w *) /

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

/[""][^""]*[""]/

ჩვენ შეგვიძლია ვითხოვოთ ბრჭყალები, რომ ემთხვეოდეს ასეთი ბმულით:

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

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

/ (ava (?: cript)?) \ sis \ s (გართობა \ w *) /

აქ ქვემეტყველება? ეს შეცვლილი ფრჩხილები არ ქმნის ბმულს, ამიტომ ამ რეჯექსში \ 2 ეხება ტექსტს, რომელიც ემთხვევა ნიმუშს (გართობა \ w *).

ქვემოთ მოცემულ ცხრილში მოცემულია ალტერნატივები, დაჯგუფება და საცნობარო ოპერატორები რეგულარულ გამონათქვამებში:

მატჩის პოზიციის მითითება

როგორც უკვე აღვნიშნეთ, რეგულარული გამოხატვის მრავალი ელემენტი ემთხვევა ერთ სტრიქონს ერთ სიმბოლოს. მაგალითად, \ s ემთხვევა ერთ სივრცის სიმბოლოს. სხვა რეგულარული გამოხატვის ელემენტები ემთხვევა პოზიციებს პერსონაჟებს შორის და არა თავად პერსონაჟებს შორის. მაგალითად, \ b ემთხვევა სიტყვის საზღვარს-საზღვარი \ w (ASCII ტექსტის სიმბოლო) და \ W (არა ტექსტური სიმბოლო), ან ზღვარი ASCII ტექსტის სიმბოლოსა და სტრიქონის დასაწყისს ან დასასრულს შორის.

ელემენტები, როგორიცაა \ b არ განსაზღვრავს სიმბოლოებს, რომლებიც უნდა იყოს ნაპოვნი სტრიქონში, მაგრამ ისინი განსაზღვრავენ შესატყვისი მოქმედ პოზიციებს. ამ ელემენტებს ზოგჯერ უწოდებენ regex წამყვან ელემენტებს, რადგან ისინი ამყარებენ ნიმუშს სიმების კონკრეტულ პოზიციაში. ყველაზე გავრცელებული წამყვანი ელემენტებია ^ და $, რომლებიც ამაგრებენ შაბლონებს, შესაბამისად, ხაზის დასაწყისსა და ბოლოს.

მაგალითად, სიტყვა "JavaScript" საკუთარ ხაზზე გვხვდება ჩვეულებრივი გამოთქმის გამოყენებით / ^ JavaScript $ /. იმისათვის, რომ იპოვოთ ერთი სიტყვა "ჯავა" (და არა პრეფიქსი, მაგალითად, სიტყვაში "JavaScript"), შეგიძლიათ სცადოთ გამოიყენოთ ნიმუში / \ sJava \ s /, რომელიც მოითხოვს სივრცეს სიტყვის წინ და მის შემდეგ.

მაგრამ ეს გადაწყვეტა წარმოშობს ორ პრობლემას. პირველ რიგში, ის იპოვის სიტყვას "ჯავა" მხოლოდ იმ შემთხვევაში, თუ იგი გარშემორტყმულია სივრცეებით ორივე მხრიდან და ვერ პოულობს მას ხაზის დასაწყისში ან ბოლოს. მეორე, როდესაც ეს ნიმუში ემთხვევა, მის მიერ დაბრუნებული სტრიქონი შეიცავს წამყვან და უკანა ადგილებს, რაც არ არის ზუსტად ის, რაც ჩვენ გვსურს. ასე რომ, შაბლონის ნაცვლად, რომელიც ემთხვევა თეთრ სივრცეს, ჩვენ გამოვიყენებთ ნიმუშს (ან წამყვანს), რომელიც შეესაბამება სიტყვის საზღვრებს \ b. შემდეგი გამოთქმა გამოვა: / \ bJava \ b /.

\ B წამყვანის ელემენტი ემთხვევა პოზიციას, რომელიც არ არის სიტყვის საზღვარი. ანუ, ნიმუში / \ Bcript / ემთხვევა სიტყვებს "JavaScript" და "postcript" და არ ემთხვევა სიტყვებს "script" ან "Scripting".

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

მაგალითად, საერთო პროგრამირების ენის შესატყვისი, რომელსაც მოჰყვება მსხვილი ნაწლავი, შეგიძლიათ გამოიყენოთ გამოთქმა / ava (cript)? (? = \ :) /. ეს ნიმუში ემთხვევა სიტყვას "JavaScript" სტრიქონში "JavaScript: Definitive Guide", მაგრამ ის არ ემთხვევა სიტყვა "Java" სტრიქონში "Java in Nutshell", რადგან მას არ მოყვება მსხვილი ნაწლავი.

თუ თქვენ შეიყვანთ მდგომარეობას (?!, მაშინ ეს იქნება უარყოფითი გამოხედვა შემდგომი სიმბოლოებისთვის, რაც მოითხოვს, რომ შემდეგი სიმბოლოები არ ემთხვეოდეს მითითებულ ნიმუშს. მაგალითად, ნიმუში / ჯავა (?! სკრიპტი) (\ w *) / ემთხვევა ქვეჯგუფს "ჯავა", რასაც მოჰყვება დიდი ასოდა ნებისმიერი რაოდენობის ASCII ტექსტური სიმბოლო, იმ პირობით, რომ ქვესატრიგს "Java" არ მოყვება ქვესიტრიქონი "Script". ის ემთხვევა სტრიქონს "JavaBeans", მაგრამ არა სტრიქონს "Javanese", ის შეესაბამება სტრიქონს "JavaScrip", მაგრამ არა სტრიქონებს "JavaScript" ან "JavaScriptpter".

ქვემოთ მოცემულ ცხრილში მოცემულია რეგულარული გამოხატვის წამყვანის სიმბოლოები:

დროშები

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

დროშა იგანმარტავს, რომ ნიმუშის შესატყვისი უნდა იყოს უმნიშვნელო და დროშა გ- რომ ძებნა უნდა იყოს გლობალური, ე.ი. სტრიქონში ყველა შესატყვისი უნდა მოიძებნოს. დროშა მეძებს ნიმუშს მრავალ ხაზოვანი რეჟიმში. თუ ძებნის სიმებიანი გამოთქმა შეიცავს ხაზის არხის სიმბოლოებს, მაშინ ამ რეჟიმში წამყვანი სიმბოლოები ^ და $, გარდა იმისა, რომ შეესაბამება მთლიანი სიმებიანი გამოხატვის დასაწყისსა და დასასრულს, ასევე ემთხვევა თითოეული ტექსტის სტრიქონის დასაწყისსა და დასასრულს. მაგალითად, / java $ / im ემთხვევა როგორც "java" - ს, ასევე "Java \ nis fun" - ს.

ეს დროშები შეიძლება გაერთიანდეს ნებისმიერ კომბინაციაში. მაგალითად, სიტყვის "java" (ან "Java", "JAVA" და ა.შ.) პირველი შემთხვევის მოსაძებნად შემთხვევისადმი მგრძნობიარე გზით, შეგიძლიათ გამოიყენოთ შემთხვევისადმი მგრძნობიარე რეგულარული გამოთქმა / \ bjava \ b / მე. და იმისათვის, რომ იპოვოთ ამ სიტყვის ყველა შემთხვევა სტრიქონში, შეგიძლიათ დაამატოთ დროშა g: / \ bjava \ b / gi.

სიმებიანი კლასის მეთოდები ნიმუშების შესატყვისად

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

სიმები მხარს უჭერს ოთხ მეთოდს რეგულარული გამონათქვამების გამოყენებით. მათგან ყველაზე მარტივი მეთოდია ძებნა ()... ის არგუმენტად იღებს რეგულარულ გამოთქმას და აბრუნებს ან ნაპოვნი ქვესტრიქონის პირველი სიმბოლოს პოზიციას, ან -1, თუ შესატყვისი არ იქნა ნაპოვნი. მაგალითად, შემდეგი ზარი დააბრუნებს 4 -ს:

Var result = "JavaScript". ძებნა ( / script / i); // 4

თუ search () მეთოდის არგუმენტი არ არის რეგულარული გამოთქმა, ის პირველად გარდაიქმნება RegExp კონსტრუქტორზე გადაცემის გზით. საძიებო () მეთოდი არ უჭერს მხარს გლობალურ ძიებებს და იგნორირებას უკეთებს g დროშას თავის არგუმენტში.

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

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

მაგალითად, ჩვენ შეგვიძლია გამოვიყენოთ შეცვლის () მეთოდი, რათა თანმიმდევრულად გამოვიტანოთ სიტყვა "JavaScript" მთელი ტექსტის სტრიქონისთვის:

// სიმბოლოების კეისის მიუხედავად, ჩაანაცვლეთ სიტყვით საჭირო შემთხვევაში var result = "javascript" .შეცვალე (/ JavaScript/ ig, "JavaScript");

შეცვლის () მეთოდი უფრო ძლიერია ვიდრე ეს მაგალითი გვთავაზობს. ნება მომეცით შეგახსენოთ, რომ რეგულარული გამოთქმის შიგნით ფრჩხილებში აღწერილი რიცხვებია მარცხნიდან მარჯვნივ და რომ რეგულარულ გამომეტყველებას ახსოვს ტექსტი, რომელიც ემთხვევა თითოეულ ქვესახეობას. თუ შემცვლელი სტრიქონი შეიცავს $, რასაც მოჰყვება ციფრი, ცვლის () მეთოდი ცვლის ამ ორ სიმბოლოს ტექსტით, რომელიც შეესაბამება მითითებულ ქვემეტყველებას. ეს არის ძალიან სასარგებლო თვისება. ჩვენ შეგვიძლია გამოვიყენოთ ის, მაგალითად, სტრიქონში სწორი ბრჭყალების შეცვლა ტიპოგრაფიული ბრჭყალებით, რომლებიც იმიტირებულია ASCII სიმბოლოებით:

// ციტატა არის ციტატა, რომელსაც მოყვება ნებისმიერი რაოდენობის არაციტირებული სიმბოლო (ჩვენ გვახსოვს ისინი), // ამ სიმბოლოებს მოყვება სხვა ციტატა var quote =/ "([^"] *) "/ g; // შეცვლა პირდაპირი ციტატები ტიპოგრაფიულებით და დატოვეთ "$ 1" უცვლელი // ციტატის შინაარსი $ 1 ინახება var text = "" JavaScript "არის ინტერპრეტირებული პროგრამირების ენა."; Var შედეგი = text.replace (ციტატა, "" $ 1 ""); // "JavaScript" არის ინტერპრეტირებული პროგრამირების ენა.

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

მეთოდი მატჩი ()არის ყველაზე გავრცელებული String კლასის რეგულარული გამოხატვის მეთოდებიდან. იგი იღებს რეგულარულ გამოთქმას, როგორც მის ერთადერთ არგუმენტს (ან არგუმენტს გადააქცევს რეგულარულ გამოხატულებად RegExp () კონსტრუქტორზე გადასვლით) და აბრუნებს მასივს, რომელიც შეიცავს ძიების შედეგებს. თუ g დროშა მითითებულია რეგულარულ გამოთქმაში, მეთოდი აბრუნებს სტრიქონში ყველა შესატყვისი მასივს. Მაგალითად:

// დააბრუნებს ["1", "2", "3"] var შედეგი = "1 პლუს 2 უდრის 3". მატჩი (/ \ d +/ გ);

თუ რეგულარული გამოთქმა არ შეიცავს g დროშას, match () მეთოდი არ ასრულებს გლობალურ ძიებას; ეს მხოლოდ პირველ მატჩს ელოდება. თუმცა, match () აბრუნებს მასივს მაშინაც კი, როდესაც მეთოდი არ ასრულებს გლობალურ ძიებას. ამ შემთხვევაში, მასივის პირველი ელემენტია ნაპოვნი ქვესტრიქონი, ხოლო ყველა დარჩენილი ელემენტი არის რეგულარული გამოხატვის ქვესახეობა. ამიტომ, თუ მატჩი () აბრუნებს მასივის arr- ს, მაშინ arr შეიცავს მთელ აღმოჩენილ სტრიქონს, arr შეიცავს ქვესტრიქონს, რომელიც ემთხვევა პირველ ქვემეტყველებას და ასე შემდეგ. შემცვლელი () მეთოდის პარალელურად, შეგვიძლია ვთქვათ, რომ arr [n] ივსება $ n შინაარსით.

მაგალითად, გადახედეთ შემდეგ კოდს URL- ის გასაანალიზებლად:

Var url = /(\w+):\/\/((\w.tory+)\/(\S*)/; var text = "ეწვიეთ ჩვენს საიტს http: //www..php"; var შედეგი = text.match (url); if (შედეგი! = null) (var fullurl = შედეგი; // შეიცავს "http: //www..php" var ოქმი = შედეგი; // შეიცავს "http" var host = result; // შეიცავს "www..php ")

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

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

"123,456,789". გაყოფა (","); // ბრუნდება ["123", "456", "789"]

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

"1, 2, 3, 4, 5". გაყოფა ( / \ s *, \ s * /); // აბრუნებს ["1", "2", "3", "4", "5"]

RegExp ობიექტი

როგორც აღვნიშნეთ, რეგულარული გამონათქვამები წარმოდგენილია როგორც RegExp ობიექტები. RegExp () კონსტრუქტორის გარდა, RegExp ობიექტები მხარს უჭერენ სამ მეთოდს და რამდენიმე თვისებას.

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

RegExp () - ს მეორე არგუმენტი შეიძლება დაკარგული იყოს. თუ მითითებულია, ის განსაზღვრავს რეგულარული გამოხატვის დროშებს. ის უნდა იყოს g, i, m ან ამ სიმბოლოების ერთ -ერთი სიმბოლო. Მაგალითად:

// პოულობს სტრიქონში ყველა 5-ნიშნა რიცხვს. შენიშვნა // \\ var zipcode = new RegExp ("\\ d (5)", "g") გამოყენება;

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

RegExp თვისებები

თითოეულ RegExp ობიექტს აქვს ხუთი თვისება. ქონება წყარო- მხოლოდ წაკითხული სტრიქონი, რომელიც შეიცავს რეგულარული გამოთქმის ტექსტს. ქონება გლობალური - ლოგიკურიმხოლოდ წაკითხული დროშა, რომელიც განსაზღვრავს g დროშას რეგულარულ გამოხატვაში. ქონება იგნორირებაარის მხოლოდ წაკითხული ლოგიკური მნიშვნელობა, რომელიც განსაზღვრავს არის თუ არა i დროშა რეგულარული გამოთქმაში. ქონება მრავალხაზოვანიარის მხოლოდ წაკითხული ლოგიკური მნიშვნელობა, რომელიც განსაზღვრავს m დროშის არსებობას რეგულარულ გამოხატვაში. და ბოლო ქონება lastIndexარის წაკითხვის / ჩაწერის მთელი რიცხვი. G დროშის მქონე შაბლონებისთვის, ეს თვისება შეიცავს პოზიციის ნომერს სტრიქონში, საიდანაც უნდა დაიწყოს შემდეგი ძებნა. როგორც ქვემოთ აღწერილია, იგი გამოიყენება exec () და test () მეთოდებით.

RegExp მეთოდები

RegExp ობიექტები განსაზღვრავს ორ მეთოდს, რომლებიც ასრულებენ შაბლონების შესაბამისობას; ისინი იქცევიან ზემოთ აღწერილი String კლასის მეთოდების მსგავსად. RegExp კლასის მთავარი მეთოდი, რომელიც გამოიყენება ნიმუშების შესატყვისად არის exec ()... იგი მსგავსია String კლასის ადრე ნახსენები match () მეთოდით, გარდა იმისა, რომ ეს არის RegExp კლასის მეთოდი, რომელიც იღებს სტრიქონს არგუმენტად და არა String კლასის მეთოდს, რომელიც იღებს RegExp არგუმენტს.

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

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

როდესაც exec () მეთოდი მეორედ იწოდება იმავე რეგულარული გამოთქმისთვის, ის იწყებს ძებნას იმ პერსონაჟზე, რომლის პოზიცია მითითებულია lastIndex თვისებაში. თუ exec () ვერ პოულობს შესატყვისს, lastIndex თვისება არის 0. (თქვენ ასევე შეგიძლიათ ნებისმიერ დროს დააყენოთ lastIndex ნულამდე, რაც უნდა გაკეთდეს ყველა იმ შემთხვევაში, როდესაც ძებნა სრულდება ბოლო მატჩამდე იმავე ხაზზე იპოვა და იწყებს ძებნას სხვა სტრიქონზე იგივე RegExp ობიექტით.) ეს განსაკუთრებული ქცევა საშუალებას აძლევს exec () -ს არაერთხელ გამოძახება სტრიქონში ყველა რეგულარული გამოხატვის შესატყვისი განმეორებით. Მაგალითად:

ვარ ნიმუში = / Java / g; var text = "JavaScript უფრო მხიარულია ვიდრე ჯავა!"; var შედეგი; while ((result = pattern.exec (ტექსტი))! = null) (console.log ("ნაპოვნია" " + შედეგი +" "" + "პოზიციაზე" + result.index + "; შემდეგი ძებნა დაიწყება" + ნიმუში. ბოლო ინდექსი);)

RegExp ობიექტის სხვა მეთოდი - ტესტი ()რაც გაცილებით მარტივია ვიდრე exec () მეთოდი. ის იღებს სტრიქონს და ბრუნდება true, თუ სტრიქონი ემთხვევა რეგულარულ გამოთქმას:

ვარ ნიმუში = / java / i; pattern.test ("JavaScript"); // აბრუნებს true

გამოძახების ტესტი () ექვივალენტურია გამოძახების exec (), დააბრუნებს true თუ exec () აბრუნებს არა-ნულს. ამ მიზეზით, ტესტი () მეთოდი იქცევა იგივე როგორც exec () მეთოდი, როდესაც გლობალური რეგულარული გამოთქმაა საჭირო: ის იწყებს მითითებული სტრიქონის ძებნას lastIndex თვისების მიერ მოცემულ პოზიციაში და თუ იპოვის შესატყვისს, ადგენს lastIndex თვისება სიმბოლოების პოზიციის ნომერზე, ნაპოვნი შესატყვისის პირდაპირ. ამიტომ, ტესტის () მეთოდის გამოყენებით, თქვენ ასევე შეგიძლიათ შექმნათ მარყუჟი ხაზის გადასალახად, როგორც exec () მეთოდით.

regex ადრე

ცნობილია რომ სასურველი სიტყვასიტყვითი სინტაქსი( / ტესტი / ი).

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

მაგრამ მიაქციეთ ყურადღება, ვინაიდან "წინ გადაწეული" \ კოდის გადართვის როლს ასრულებს, სიტყვასიტყვით სტრიქონში (ახალი RegExp) ის ორჯერ უნდა დაიწეროს: \\

დროშები

მე იგნორირებას უკეთებს შემთხვევას, როდესაც ემთხვევა

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

ოპერატორები

პერსონაჟების წინასწარ განსაზღვრული კლასები

დაჯგუფება ()

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

ფიქსაცია

ფრჩხილებში ჩასმული რეგულარული გამოთქმის ნაწილს () ეწოდება ფიქსაცია.

განვიხილოთ შემდეგი მაგალითი:

/ ^ () კ \ 1 /

\ 1 არ არის a, b, c სიმბოლო.
\ 1 არის ნებისმიერი სიმბოლო, რომელიც იწყებს ემთხვევა პირველ პერსონაჟს... ანუ \ 1 – თან შესატყვისი სიმბოლო უცნობია სანამ რეგექსი არ მოგვარდება.

არასტაბილური ჯგუფები

ფრჩხილები () გამოიყენება 2 შემთხვევაში: დაჯგუფებისათვის და ჩადენისათვის. მაგრამ არის სიტუაციები, როდესაც ჩვენ უნდა გამოვიყენოთ () მხოლოდ დაჯგუფებისათვის, ვინაიდან არანაირი ვალდებულება არ არის საჭირო, გარდა ამისა, არასაჭირო ვალდებულებების ამოღებით, ჩვენ ვაადვილებთ რეგულარული გამოხატვის დამუშავების ძრავას.

ასე რომ ჩადენის თავიდან აცილებაფრჩხილის გახსნამდე უნდა ჩაწეროთ:?:

ქუჩა = "

" ]

ტესტის ფუნქცია

Regexp.test ()

ტესტის ფუნქცია ამოწმებს შეესაბამება თუ არა რეგულარული გამოთქმა სტრიქონს (str). ბრუნდება ან ჭეშმარიტი ან მცდარი.

გამოყენების მაგალითი:

Javascript

ფუნქციის კოდი F (str) (return /^\d(5)-\d(2)/.test(str);) //console.log(codeF("12345-12ss ")); // ჭეშმარიტი //console.log(codeF("1245-12ss ")); // ყალბი

მატჩის ფუნქცია

str.match (regexp)

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

Javascript

str = "ინფორმაციისთვის იხ .: თავი 3.4.5.1"; re = / head (\ d + (\. \ d) *) / i // საკომისიოებით (გლობალური ჩამრთველი არ არის) ნაპოვნია = str.match (ხელახლა) console.log (ნაპოვნია); // ["თავი 3.4.5.1", "3.4.5.1", ".1"]

თუ თქვენ ემთხვევით () მეთოდს გლობალური რეგულარული გამოხატულებით (დროში g), მაშინ მასივიც დაბრუნდება, მაგრამ გლობალური მატჩებით... ანუ, არცერთი ვალდებული შედეგი არ ბრუნდება.

Javascript

str = "ინფორმაციისთვის იხ .: თავი 3.4.5.1, თავი 7.5"; re = / head (\ d + (\. \ d) *) / ig // არ ჩადება - გლობალურად ნაპოვნია = str.match (re) console.log (ნაპოვნია); // ["თავი 3.4.5.1", "თავი 7.5"]

შესრულების ფუნქცია

regexp.exec (str)

Exec ფუნქცია ამოწმებს შეესაბამება თუ არა რეგულარული გამოთქმა სტრიქონს (str). აბრუნებს შედეგების მასივს (კომიტეტებით) ან null. ყოველი მომდევნო ზარი exec მეთოდზე (მაგალითად, while გამოყენებისას) ხდება (იმის გამო ავტომატური განახლებაბოლო ძიების ბოლოს lastIndex- ის ინდექსის შესრულებისას) გადადით შემდეგ გლობალურ მატჩზე (თუ დროშა g არის შემოწმებული).

Javascript

var html = "

BAM! ბუმბერაზი!

"; var reg = /<(\/?)(\w+)([^>] *?)> / გ; //console.log(reg.exec(html)); // ["

"," "," div "," class = "test" "] while ((match = reg.exec (html))! == null) (console.log (reg.exec (html));) / * [" "," "," ბ "," "] [" "," "," em "," "] ["

"," / "," div "," "] * /

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

Javascript

// ემთხვევა var html = "

BAM! ბუმბერაზი!

"; var reg = /<(\/?)(\w+)([^>] *?)> /; // არ არსებობს გლობალური კონსოლი.ლოგი (html.match (reg)); // ["

"," "," div "," class = "ტესტი" "] // exec var html ="

BAM! ბუმბერაზი!

"; var reg = /<(\/?)(\w+)([^>] *?)> /; // გლობალური კონსოლი არ არის (reg.exec (html)); // ["

"," "," div "," class = "ტესტი" "]

შეცვალეთ ფუნქცია

ქ. შეცვლა (regexp, newSubStr | ფუნქცია)

• regexp - რეგ. გამოხატვა;
• newSubStr - ხაზი, რომელზედაც იცვლება ტექსტში ნაპოვნი გამოთქმა;
• ფუნქცია - გამოიძახება ყველა შესატყვისი ნაპოვნი ცვლადი პარამეტრების სიით (შეგახსენებთ, რომ გლობალური ძებნა სტრიქონში პოულობს ნიმუშის შესატყვისის ყველა შემთხვევას).

ამ ფუნქციის დაბრუნების მნიშვნელობა ემსახურება როგორც შემცვლელს.

ფუნქციის პარამეტრები:

• 1 - სრული შესაბამისი ქვესტრიქონი.
• 2 - ფრჩხილის ჯგუფების მნიშვნელობა (ფიქსაციები).
• 3 - შესატყვისი ინდექსი (პოზიცია) თავდაპირველ სტრიქონში.
• 4 - ორიგინალური სტრიქონი.

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

"GHGHGHGTTTT" .შეცვლა (// გ, "K"); // "KKKKKKKKKKKK"

Javascript

ფუნქცია upLetter (allStr, letter) (დაბრუნების letter.toUpperCase ();) var res = "border-top-width" .შეცვალე ( /-(\ w) / g, upLetter); console.log (რეს); // borderTopWidth

ბოლო განახლება: 1.11.2015

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

რეგულარული გამოხატვის განსაზღვრის ორი გზა არსებობს:

Var myExp = / გამარჯობა /; var myExp = ახალი RegExp ("გამარჯობა");

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

RegExp მეთოდები

იმის დასადგენად, შეესაბამება თუ არა რეგულარული გამოთქმა სტრიქონს, ტესტი () მეთოდი განსაზღვრულია RegExp ობიექტში. ეს მეთოდი აბრუნებს true თუ სტრიქონი შეესაბამება ჩვეულებრივ გამოთქმას და false თუ არა.

Var initialText = "გამარჯობა სამყარო!"; var exp = / გამარჯობა /; var შედეგი = exp.test (initialText); document.write (შედეგი + "
"); // ჭეშმარიტი initialText =" მშვენიერი ამინდი "; შედეგი = exp.test (initialText); document.write (შედეგი); // false - არ არსებობს" hello "in საწყის ტექსტის ხაზში

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

Var initialText = "გამარჯობა სამყარო!"; var exp = / გამარჯობა /; var შედეგი = exp.exec (initialText); document.write (შედეგი + "
"); // გამარჯობა initialText =" ულამაზესი ამინდი "; result = exp.exec (initialText); document.write (შედეგი); // null

პერსონაჟთა ჯგუფები

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

Var initialText = "დაცვა"; var exp = / [abc] /; var შედეგი = exp.test (initialText); document.write (შედეგი + "
"); // ჭეშმარიტი initialText =" ქალაქი "; შედეგი = exp.test (initialText); document.write (შედეგი); // მცდარი

გამოთქმა [abc] მიუთითებს, რომ სტრიქონს უნდა ჰქონდეს სამი ასოდან ერთი.

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

Var initialText = "დაცვა"; var exp = / [a-z] /; var შედეგი = exp.test (initialText); document.write (შედეგი + "
"); // ჭეშმარიტი initialText =" 3di0789 "; შედეგი = exp.test (initialText); document.write (შედეგი); // მცდარი

ამ შემთხვევაში, სტრიქონი უნდა შეიცავდეს მინიმუმ ერთ სიმბოლოს დიაპაზონი a-z.

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

Var initialText = "დაცვა"; var exp = / [^ a-z] /; var შედეგი = exp.test (initialText); document.write (შედეგი + "
"); // ცრუ initialText =" 3di0789 "; exp = / [^ 0-9] /; result = exp.test (initialText); document.write (შედეგი); // true

პირველ შემთხვევაში, სტრიქონს არ უნდა ჰქონდეს მხოლოდ az დიაპაზონის სიმბოლოები, მაგრამ რადგან სტრიქონი "defenses" შედგება მხოლოდ ამ დიაპაზონის სიმბოლოებისგან, test () მეთოდი აბრუნებს false, ანუ რეგულარული გამოთქმა არ ემთხვევა მარაგი.

მეორე შემთხვევაში ("3di0789"), სტრიქონი არ უნდა შეიცავდეს მხოლოდ ციფრულ სიმბოლოებს. მაგრამ რადგან სტრიქონი ასევე შეიცავს ასოებს, სტრიქონი ემთხვევა რეგულარულ გამოთქმას, ამიტომ ტესტის მეთოდი ბრუნდება ჭეშმარიტი.

საჭიროების შემთხვევაში, ჩვენ შეგვიძლია შევაგროვოთ გამონათქვამების კომბინაცია:

Var initialText = "მთავარი"; var exp = / [dt] o [nm] /; var შედეგი = exp.test (initialText); document.write (შედეგი); // მართალია

გამოთქმა [dt] o [nm] მიუთითებს იმ სტრიქონებს, რომლებიც შეიძლება შეიცავდეს ქვესიტრიქონებს "სახლი", "ტომი", "დონი", "ტონი".

გამოხატვის თვისებები

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

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

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

Მაგალითად:

Var initialText = "გამარჯობა სამყარო"; var exp = / world /; var შედეგი = exp.test (initialText); // ყალბი

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

Var exp = / world / i;

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

დაწკაპუნებები და ზედმეტი ხმები კომპიუტერიდან

როგორ შევქმნათ სრული ეკრანის რეჟიმი თამაშში

შეცდომები EDGE- ში? შენელდება თამაში? დაფრინავს გარეთ? აგვარებს ყველაზე გავრცელებულ პრობლემებს. Mirrors Edge არ დაიწყება, არ იმუშავებს, არ დააინსტალირებს In Mirror's Edge: კატალიზატორი შავი ეკრანი, თეთრი ეკრანი, ფერადი ეკრანი.

მეკობრეების ბრძოლის ველი 2 ჩამოვარდა დაწყებისთანავე