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

რეგულარული გამონათქვამები არის გამონათქვამები, რომლებიც დაწერილია სპეციალურ ენაზე.

არ ინერვიულოთ, ენა საკმაოდ მარტივი გასაგებია, მხოლოდ გამოცდილება და პრაქტიკა გჭირდებათ. ვფიქრობ, თქვენ არაერთხელ შეგხვედრიათ სიტუაციები, როდესაც გაქვთ ტექსტი (მაგალითად, in Microsoft Word

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

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

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

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

// წაკითხვადი სიმბოლოები a E // წაუკითხავი სიმბოლოები და კოდები \x41 - იგივე ასო "A" \x09 - ჩანართის სიმბოლო

პერსონაჟთა ჯგუფი არის რამდენიმე სიმბოლო, რომელიც იწერება თანმიმდევრობით:

Abvg ACZms

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

ABC WHERE ABC სად

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

მეტაგმირები სპეციალური სიმბოლოების მითითებისთვის
()	ფრჩხილები. განსაზღვრავს წყობილ გამონათქვამებს.
|	შერჩევის მეტაპერსონაჟი
^	ხაზის დასაწყისი მეტახასიათი
$	ხაზის ბოლოს მეტაპერსონაჟი
\n	ხაზის არხის სიმბოლო (ექვსკუთხედი კოდი 0x0A)
\r	ვაგონის დაბრუნების სიმბოლო (ექვსკუთხედი კოდი 0x0D)
\ ტ	ჩანართის სიმბოლო (ექვსკუთხედი კოდი 0x09)
\ ჩხ	სიმბოლოს ჩასმა თექვსმეტობითი კოდით 0xhh, მაგალითად, \x42 ჩასვამს ლათინურ ასოს "B"
მეტაგმირები სიმბოლოთა ჯგუფების მითითებისთვის
.	წერტილი. ნებისმიერი პერსონაჟი.
\ დ	ციფრი (0-9)
\დ	არა რიცხვი (ნებისმიერი სიმბოლო სიმბოლოების გარდა 0-9)
\ ს	ცარიელი სიმბოლო (ჩვეულებრივ სივრცე და ჩანართი)
\ ს	არა ცარიელი სიმბოლო (ყველა სიმბოლოების გარდა, რომლებიც იდენტიფიცირებულია \s მეტახასიათებით)
\w	"ლექსიკონის" სიმბოლო (სიმბოლო, რომელიც გამოიყენება სიტყვებში. როგორც წესი, ყველა ასო, ყველა რიცხვი და ქვედა ხაზი ("_"))
\ვ	ყველა სიმბოლოს გარდა, რომელიც განსაზღვრულია \w მეტანიშანით

ცხრილის მეორე ნახევრის მეტაპერსონაჟები ძალიან ადვილი დასამახსოვრებელია. "d" - ციფრი (ციფრი), "s" - სიმბოლო (სიმბოლო), "w" - სიტყვა (სიტყვა). თუ ასო დიდია, მაშინ თქვენ უნდა დაამატოთ "NOT" ჯგუფის აღწერაში.

მაგალითად ავიღოთ ტექსტი „წითელ მაისურს აქვს ნომრები 1812, ხოლო მწვანე მაისურს აქვს ნომრები 2009“. მოდით შევხედოთ უმარტივესი რეგულარული გამონათქვამების მაგალითებს:

\d\d\d\d - იპოვის 1812 და 2009 \D - იპოვის ყველა ასოს, სივრცეს და პუნქტუაციის ნიშანს \s - იპოვის ყველა სივრცეს ტექსტში.

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

ნიშნავს ნებისმიერ ციფრს (იგივე \d) - ნიშნავს ლუწი ციფრს - ნიშნავს ლათინური ანბანის ნებისმიერ სიმბოლოს (ნებისმიერ შემთხვევაში) ან ციფრს.

მაგალითად, გამოთქმა \d\d\d ტესტის სტრიქონში იპოვის მხოლოდ 1812-ს, მაგრამ არა 2009-ს. ეს გამოთქმა უნდა წაიკითხოს როგორც "იპოვე ოთხი ციფრის ყველა მიმდევრობა, სადაც ბოლო ციფრი არის 0,2,4,6 ან 8".

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

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

აქ X არის წინა სიმბოლო ან ჯგუფის გამეორების რაოდენობა. მაგალითად გამოთქმა

ჩაწერის მეორე ფორმა არის დიაპაზონი. ჩაწერილია როგორც

(X, Y) // ან (,Y) // ან (X,)

სადაც X არის მინიმალური და Y არის გამეორებების მაქსიმალური რაოდენობა. მაგალითად:

წაიკითხეთ როგორც "ორი-ოთხი ციფრი დაწერილი თანმიმდევრობით." თუ რომელიმე საზღვარი არ არის მითითებული, მაშინ არანაირი შეზღუდვა არ არის გათვალისწინებული. მაგალითად:

\w(3,) - სამი ან მეტი ასო. \d(,5) - რიცხვები საერთოდ არ არის, ან არის, მაგრამ არაუმეტეს ხუთი.

რაოდენობები შეიძლება გამოყენებულ იქნას როგორც ერთ სიმბოლოზე, ასევე ჯგუფზე:

[A-Yaa-ya](1,3)

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

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

მეტანიშანი "*" იკითხება როგორც "ნებისმიერი თანხა ნულიდან ან მეტიდან", ე.ი. დიზაინი

განსაზღვრავს თანმიმდევრული ასოების ნებისმიერ რაოდენობას, მათ შორის მათ სრულ არარსებობას.

სიმბოლო "+" ვარსკვლავისგან განსხვავდება მხოლოდ იმით, რომ ის მოითხოვს მინიმუმ ერთი სიმბოლოს არსებობას. იმათ. დიზაინი

შეესაბამება ნებისმიერ ციფრულ თანმიმდევრობას ერთი ან მეტი ციფრით.

სიმბოლო "?" შეესაბამება ერთი პერსონაჟის არარსებობას ან არსებობას. იმათ. დიზაინი

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

აქ უნდა აღინიშნოს ანტიიფიკატორების "*" და "+" ისეთი თვისება, როგორიცაა სიხარბე. საქმე იმაშია, რომ ნაგულისხმევად ეს სიმბოლოები შეესაბამება სიმბოლოების მაქსიმალურ შესაძლო თანმიმდევრობას. მაგალითად, სტრიქონისთვის „დედამ ჩარჩო გარეცხა“ გამოთქმა:

აირჩევს "mama soap ra", რაც გარკვეულწილად მოულოდნელია, რადგან ველოდით, რომ "ma"-ს მივიღებდით. ამ ქცევის შესაცვლელად გამოიყენეთ მეტანიშანი "?" (კითხვის ნიშანი) დაწერილი დაუყოვნებლივ კვანტიფიკატორის შემდეგ. ის ზღუდავს კვანტიფიკატორების „მადას“ და აიძულებს მათ დააბრუნონ პირველი მატჩი და არა ყველაზე გრძელი. ახლა შევცვალოთ წინა მაგალითი:

და მიიღეთ საჭირო შესატყვისი "მა".

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

მე	რთავს რეგისტრის უგრძნობ რეჟიმს, ე.ი. დიდი და პატარა ასოები გამოხატულებაში არ განსხვავდება.
მ	მიუთითებს, რომ საძიებო ტექსტი უნდა განიხილებოდეს, როგორც მრავალი სტრიქონისაგან შემდგარი. ნაგულისხმევად, რეგულარული გამოხატვის ძრავა ტექსტს განიხილავს, როგორც ერთ სტრიქონს, მიუხედავად იმისა, თუ რა არის ის სინამდვილეში. შესაბამისად, მეტანიშვნები „^“ და „$“ მიუთითებს მთელი ტექსტის დასაწყისსა და დასასრულს. თუ ეს მოდიფიკატორი მითითებულია, მაშინ ისინი მიუთითებენ, შესაბამისად, ტექსტის თითოეული ხაზის დასაწყისსა და დასასრულს.
ს	ნაგულისხმევი მეტანიშანი არის "." არ შეიცავს ახალი ხაზის სიმბოლოს მის განმარტებაში. იმათ. მრავალხაზოვანი ტექსტისთვის, გამოხატულება /.+/ დააბრუნებს მხოლოდ პირველ სტრიქონს და არა მთელ ტექსტს, როგორც მოსალოდნელი იყო. ამ მოდიფიკატორის მითითება მოხსნის ამ შეზღუდვას.
უ	ნაგულისხმევად აქცევს ყველა რაოდენობრივ მეტანიშანს „არახარბს“. ენის ზოგიერთ მოდიფიკაციაში (კერძოდ PHP-ში), "U"-ს ნაცვლად გამოიყენება სიმბოლო "g", რომელიც უფრო შეესაბამება მნიშვნელობას ("g" არის მოკლე ინგლისური "greedy", "greedy" ).

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

რეგულარული გამონათქვამები PHP-ში.

PHP-ში რეგულარულ გამონათქვამებთან მუშაობისთვის არის სპეციალური ფუნქციები, რომელთა ჩამონათვალიც მოკლე აღწერამოცემულია ცხრილში:

int preg_match (სტრიქონის ნიმუში, სტრიქონის საგანი [, მასივის შესატყვისები])

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

int preg_match_all (სტრიქონის ნიმუში, სტრიქონის თემა, მასივის შესატყვისი [, int თანმიმდევრობა])

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

შერეული preg_replace (შერეული ნიმუში, შერეული ჩანაცვლება, შერეული თემა [, int ლიმიტი])

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

შერეული preg_replace_callback (შერეული ნიმუში, შერეული გამოძახება, შერეული თემა [, int limit])

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

მასივი preg_split (სტრიქონის ნიმუში, სტრიქონის თემა [, int ლიმიტი [, int flags]])

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

მასივი preg_grep (სტრიქონის ნიმუში, მასივის შეყვანა)

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

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

დავიწყოთ იმით, თუ რა არის რეგულარული გამოხატულება. ასე რომ, მიპასუხეთ ამ კითხვაზე: არის თუ არა "ე" სიტყვა "ტესტში"? "ჭამე!" შენ ამბობ. მერე მეორე კითხვას დაგისვამ, როგორ იპოვე ასო „ე“ სიტყვა „ტესტში“? პასუხი აშკარაა, ვიღებთ პირველ სიმბოლოს, ანუ „ტ“-ს და ვადარებთ იმას, რასაც ვეძებთ, ანუ „ე“-ს. თუ ისინი არ არიან თანაბარი, მაშინ ვიღებთ მეორე სიმბოლოს, ანუ „ე“-ს და ვადარებთ იმას, რასაც ვეძებთ, ანუ „ე“. ვოილა! ასანთი იპოვეს. პასუხი: სიტყვა „ტესტი“ შეიცავს ასო „ე“.

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

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

პირველი რეგულარული გამოხატულება

თეორიულად, ჩვენ გვესმის, როგორ ვიპოვოთ სიმბოლო "ე" სიტყვა "ტესტში", მაგრამ როგორ ხორციელდება ეს პრაქტიკაში? php-ში რეგულარული გამონათქვამების გამოსაყენებლად, ჩვეულებრივ გამოიყენება შემდეგი ფუნქციები:

preg_match("რეგულარული გამოხატულება (ნიმუში)", "ცვლადი, რომელშიც შესრულებულია ძებნა", "ცვლადი, რომელშიც შენახულია ძიების შედეგი (სურვილისამებრ პარამეტრი)"); - შესატყვისი ფუნქცია
preg_replace("ჩვეულებრივი გამოხატულება (ნიმუში)", "რით შევცვალო ნაპოვნი შესატყვისი", "ცვლადი, რომელშიც ჩანაცვლება ხდება"); - ჩანაცვლება ფუნქცია

დავიწყოთ ამ ფუნქციების გამოყენება სიტყვა "ტესტში" სიმბოლო "e"-ს ძიების მაგალითი.

$a = "ტესტი";
if(preg_match("/e/",$a)) echo "იპოვეს!!";

კოდი აღწერს მდგომარეობას: თუ $a ცვლადში ნაპოვნია ნიმუშის შესატყვისი, მაშინ აჩვენეთ შეტყობინება "აღმოაჩინეს!!" როგორც თქვენ შენიშნეთ, ჩვენი შაბლონი მდებარეობს ორ "/"-ს შორის. ამ შემთხვევაში, სიმბოლო "/" სიმბოლოა ჩვენი ნიმუშის დასაწყისსა და დასასრულს. იმედი მაქვს, რომ ეს გასაგებია.

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

როგორ მოვძებნოთ ეს წერილი? შეიძლება არსებობდეს ინგლისური ანბანის ნებისმიერი ასო, ასე რომ, როგორ შეგიძლიათ მისი ამოცნობა? თქვენ თვითონ უპასუხეთ თქვენს კითხვას, არის ნებისმიერი ასო, ანუ ის არის a-დან z-მდე დიაპაზონში. თქვენ შეგიძლიათ გამოიყენოთ დიაპაზონები რეგულარულ გამონათქვამებში. თუ არ ვიცით, რომელ პერსონაჟს ვეძებთ, მაგრამ ზუსტად ვიცით, რომ ეს სიმბოლო ინგლისური ანბანის ასოა, მაშინ ჩანაწერი იქნება შემდეგი:

$a = "123a321";
if(preg_match("//",$a)) echo "იპოვეს!!";

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

$a = "abc1cba";
if(preg_match("//",$a)) echo "იპოვეს!!";

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

$a = "123a321";
if(preg_match("//",$a)) echo "იპოვეს!!";

ასევე არსებობს რუსული ასოების ძებნა, რომელიც ხორციელდება ისევე, როგორც ინგლისურში:

$a = "123×321";
if(preg_match("/[a-zA-Z]/",$a)) echo "იპოვეს!!";

მეტახასიათები

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

ხაზი - 123a321
ნიმუში -

ჰმ... შაბლონი ფაქტობრივად ემთხვევა ჩვენს სტრიქონს და შესაბამისობის შემოწმებისას ის მისცემს დიდი ხნის ნანატრი ჭეშმარიტებას! მაგრამ ეს ერთგვარი შრომატევადი ჩანაწერია, არ ფიქრობთ?

აი, როგორ შევამოკლოთ ის:

ხაზი - 123a321
ნიმუში - *

მეჩვენება, რომ ეს უფრო მოკლეა, რა არის "*" სიმბოლო? ეს არის იგივე მეტასიმბოლო, ეს ნიშნავს, რომ ჩვენ მიერ აღწერილი სიმბოლო (კერძოდ, სიმბოლო, რომელიც შეიძლება შეიცავდეს რიცხვებს 0-დან 9-მდე ან ინგლისური ანბანის ასოებს, a-დან z-მდე) შეიძლება განმეორდეს განუსაზღვრელი ვადით, ან ერთზე მეტჯერ. დიახ დიახ! ეს მეტასიმბოლო იპოვის შესატყვისს ცარიელ ცვლადში, რადგან ჩვენ მიერ აღწერილი სიმბოლოს არარსებობაც კი დაბრუნდება ჭეშმარიტად! დაიმახსოვრე ეს

სხვა რა მეტახასიათები არსებობს?

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

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

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

$a = "qwerty12345";

რა პერსონაჟები მივეცით? ნებისმიერი საქმის ინგლისური ასოები და რიცხვები. ახლა შეეცადეთ დატოვოთ ცარიელი ხაზი პაროლის ნაცვლად.

$a = "";
if(preg_match("/+/",$a)) echo "პაროლი სწორია";

თქვენ ვერ ნახავთ შეტყობინებას "პაროლი სწორია". რატომ? იმის გამო, რომ "+" მეტანიშანმა შეამოწმა სტრიქონი, რომ ენახა თუ არა მას ერთი სიმბოლო მაინც.

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

$a = "qwerty12345";
if(preg_match("/+/",$a)) echo "პაროლი სწორია";

და რატომ ვხედავთ ჩვენს შეტყობინებას სწორი პაროლის შესახებ? ეს საკმაოდ მარტივია... ფუნქცია preg_match(); წყვეტს მის შემოწმებას პირველივე მატჩზე. ანუ სიმბოლო „q“ ერგება ჩვენ მიერ აღწერილ შაბლონს და სხვა ყველაფერი აღარ არის მნიშვნელოვანი ფუნქციისთვის რა უნდა გავაკეთოთ? აი, როგორ გამოვასწოროთ:

$a = "qwerty12345";
if(preg_match("/^+$/",$a)) echo "პაროლი სწორია";

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

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

ზოგჯერ "არა" უკეთესია

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

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

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

$a = "a-_+()";
if(preg_match("/^[^0-9]+$/",$a)) echo "ნომრები არ არის!";

როგორ მივაღწიეთ ამას? ჩვენ შევიტანეთ სიმბოლო, მაგრამ!

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

ვნახე და გადავარჩინე!

ჩემი ბლოგი

$a = " ჩემი ბლოგი";
preg_match("/ /", $a);

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

$a = " ჩემი ბლოგი";
preg_match("/ /", $a, $b);

შესაბამისად, საჭიროა დამატებითი პარამეტრის დამატება $b ცვლადის სახით, რომელშიც შეინახება ნაპოვნი ბმული. თქვენ ასევე უნდა იცოდეთ, რომ ძიების შედეგი მოთავსებულია მასივში. აქედან გამომდინარე, ცვლადი $b არის მასივი. ინფორმაცია, რომელსაც ჩვენ ვეძებთ, არის ინდექსში 1. ეს ნიშნავს, რომ ძიების შედეგი არის $b ცვლადში. მოდით გამოვხატოთ შედეგი ეკრანზე:

$a = " ჩემი ბლოგი";
preg_match("/ /", $a, $b);
ექო $b;

სწორი მისამართი წარმატების გასაღებია!

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

• ინგლისური ასოები, რიცხვები, „_“, „-“ მმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმმამამარაგადაამარაგასამარაგები,ინგლისური ასოები.
• შემდეგი გვაქვს "@"
• შემდეგ ინგლისური ასოები
• შემდეგი, პერიოდი
• და ისევ ინგლისური ასოები...

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

$a = " [ელფოსტა დაცულია]";
if(preg_match("/^+@+.+$/", $a)) echo "ელ.ფოსტის მისამართი სწორია!";
else echo "ელ.ფოსტის მისამართი სწორად არ არის დაწერილი!";

ჰოდა... იმედი მაქვს, რომ ასეთი ჩანაწერები ახლა არ შეგაშინებთ და საკმაოდ კარგად გაიგებთ მათ.

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

რაც შეეხება სტატიების სერიას cms ბლოგის შემუშავებაზე, სერიის პირველ ნაწილს დახურულად ვაცხადებ!

რეგულარული გამონათქვამები საშუალებას გაძლევთ იპოვოთ თანმიმდევრობები სტრიქონში, რომლებიც შეესაბამება ნიმუშს. მაგალითად, შაბლონი „Vasya(.*)Pupkin“ საშუალებას მოგცემთ იპოვოთ თანმიმდევრობა, როდესაც სიტყვებს Vasya-სა და Pupkin-ს შორის არის ნებისმიერი სიმბოლოების რაოდენობა. თუ ექვსი ციფრი უნდა ვიპოვოთ, მაშინ ვწერთ "(6)" (თუ, მაგალითად, ექვსიდან რვა ციფრიდან, მაშინ "(6,8)"). ეს განასხვავებს ისეთ რაღაცეებს, როგორიცაა სიმბოლოების ნაკრების ინდიკატორი და საჭირო რაოდენობის ინდიკატორი:

სიმბოლოების ნაკრების ნაცვლად, შეიძლება გამოყენებულ იქნას ნებისმიერი სიმბოლოს აღნიშვნა - შეიძლება მიუთითოთ სიმბოლოების კონკრეტული ნაკრები (მიმდევრობა მხარდაჭერილია - აღნიშნული "0-9"). შეიძლება მიუთითებდეს „გარდაეს ნაკრები

პერსონაჟები". სიმბოლოების რაოდენობას ოფიციალურ PHP დოკუმენტაციაში ეწოდება "რაოდენობა". ტერმინი მოსახერხებელია და არ შეიცავს გაუგებრობას. ასე რომ, კვანტიფიკატორს შეიძლება ჰქონდეს კონკრეტული მნიშვნელობა - ან ერთი ფიქსირებული მნიშვნელობა ("(6)"), ან რიცხვითი ინტერვალი ("(6,8)"), ან აბსტრაქტული "ნებისმიერი რიცხვი, მათ შორის 0" ("( "*"), "ნებისმიერიბუნებრივი რიცხვი

" - 1-დან უსასრულობამდე ("+": "document+.txt"), "ან 0 ან 1" ("?"). ნაგულისხმევი რაოდენობრივი მაჩვენებელი ამ სიმბოლოების ნაკრებისთვის არის ერთი ("document.txt").

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

ნებისმიერი მოქნილი ხელსაწყოს მსგავსად, რეგულარული გამონათქვამები მოქნილია, მაგრამ არა აბსოლუტურად: მათი გამოყენების არეალი შეზღუდულია. მაგალითად, თუ თქვენ გჭირდებათ ტექსტში ერთი ფიქსირებული სტრიქონის შეცვლა მეორეთი, ისევ დაფიქსირდით, გამოიყენეთ str_replace. PHP-ის დეველოპერები თვალცრემლიანი გევედრებიან, არ გამოიყენოთ რთული ფუნქციები ereg_replace ან preg_replace ამ მიზნით, რადგან მათი გამოძახებისას ხდება სტრიქონების ინტერპრეტაციის პროცესი და ეს სერიოზულად მოიხმარს სისტემის რესურსებს. სამწუხაროდ, ეს არის დამწყები PHP პროგრამისტების საყვარელი საკომისიო. გამოიყენეთ რეგულარული გამოხატვის ფუნქციები მხოლოდ იმ შემთხვევაში, თუ ზუსტად არ იცით რა სტრიქონი არსებობს. მაგალითები: საძიებო კოდი, რომელშიც სერვისის სიმბოლოები და მოკლე სიტყვები ამოჭრილია საძიებო სტრიქონიდან, ასევე ამოჭრილია დამატებითი სივრცეები (უფრო სწორად, ყველა სივრცე შეკუმშულია: „+“ იცვლება ერთი ინტერვალით). ამ ფუნქციების გამოყენებით, მე ვამოწმებ მომხმარებლის ელფოსტას, რომელიც ტოვებს მიმოხილვას. ბევრი რამის გაკეთება შეიძლება, მაგრამ მნიშვნელოვანია გვახსოვდეს, რომ რეგულარული გამონათქვამები არ არის ყოვლისშემძლე. მაგალითად, რთული ჩანაცვლებაუმჯობესია არ გააკეთოთ ისინი. ბოლოს და ბოლოს, მაგალითად, კომბინაცია „(.*)“ პროგრამის ტერმინებში ნიშნავს ტექსტის ყველა სიმბოლოს ძიებას. და თუ შაბლონი არ არის მიბმული სტრიქონის დასაწყისთან ან დასასრულთან, მაშინ თავად შაბლონი "გადაადგილდება" პროგრამის მიერ მთელ ტექსტში და შედეგი არის ორმაგი ძებნა, უფრო სწორად, ძიება კვადრატში. ძნელი მისახვედრი არ არის, რომ სხვა კომბინაცია „(.*)“ ნიშნავს კუბზე გამეორებას და ა.შ. აწიეთ, ვთქვათ, 5 კილობაიტი ტექსტი მესამე ხარისხზე. გამოდის 125 000 000 000 (სიტყვით: ას ოცდახუთი მილიარდი ოპერაცია). რა თქმა უნდა, თუ მკაცრ მიდგომას გამოიყენებთ, ამდენი ოპერაცია არ იქნება, მაგრამ ოთხჯერ რვაჯერ ნაკლები, მაგრამ თავად რიცხვების თანმიმდევრობა მნიშვნელოვანია.

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

.	წერტილი	ნებისმიერი პერსონაჟი
[]	კვადრატული ფრჩხილები	პერსონაჟების კლასი ("ნებისმიერი"). მაგალითად
[^]		უარყოფითი პერსონაჟების კლასი ("ნებისმიერი გარდა")
-	ტირე	თანმიმდევრობის აღნიშვნა სიმბოლოთა კლასში ("" ციფრები)
\ დ		მხოლოდ ნომრები
\დ	[^0-9]	რიცხვების გარდა
\w		ასოები და რიცხვები
\ვ	[^a-z0-9]	ასოებისა და ციფრების გარდა
\ ს		თეთრი სივრცის სიმბოლოები: სივრცე, ჩანართი, ახალი ხაზი
\ ს	[^ ]	გარდა უფსკრული სიმბოლოებისა
|	(ერთი | მეორე)	ამ ადგილას შეიძლება იყოს ერთ-ერთი ჩამოთვლილი ვარიანტი, მაგალითად: (ვასია|პეტია|მაშა). თუ არ გსურთ, რომ ის შევიდეს შერჩევაში, გამოიყენეთ (?: ...)

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

კვანტიფიკატორი

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

{ }

{ , }

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

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

წამყვანები

ეს სიმბოლოები უნდა გამოჩნდეს ხაზის დასაწყისში და ბოლოს, შესაბამისად.

სიხარბე კითხვის ნიშანი ასევე მოქმედებს როგორც რაოდენობრივი მინიმიზატორი:
.*?

მაგალითის შედეგი: ხარბ ვერსია: თამამი ტექსტი [b]და აქ - კიდევ უფრო თამამი დაბრუნებული ზარმაცი ვერსია: თამამი ტექსტი [b]და აქ - კიდევ უფრო თამამი დაბრუნდა

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

მე	საქმისადმი მგრძნობიარე ძიება
მ	მრავალხაზოვანი რეჟიმი. ნაგულისხმევად, PCRE ეძებს შაბლონების შესატყვისს მხოლოდ ერთი ხაზის ფარგლებში, ხოლო "^" და "$" სიმბოლოები ემთხვევა მხოლოდ მთელი ტექსტის დასაწყისს და დასასრულს.
ს	როდესაც ეს პარამეტრი დაყენებულია, "^" და "$" ემთხვევა ცალკეული ხაზების დასაწყისს და დასასრულს.
სიმბოლო "." (წერტილი) ასევე შეესაბამება ხაზის წყვეტას (ნაგულისხმევი არა)	ა
მიამაგრეთ ტექსტის დასაწყისში	ე
უ	აიძულებს "$" სიმბოლოს შეესაბამებოდეს მხოლოდ ტექსტის ბოლოს.
იგნორირებულია, თუ პარამეტრი m დაყენებულია.	აბრუნებს "ხარბს" თითოეული კვანტიფიკატორისთვის (თუ რაოდენობრივ მაჩვენებელს მოჰყვება "?", ეს კვანტიფიკატორი აღარ არის "ხარბი").

ე

• შემცვლელი სტრიქონი ინტერპრეტირებულია, როგორც PHP კოდი.
• რეგულარულ გამონათქვამებთან მუშაობის ფუნქციები preg_grep preg_match - ასრულებს მატჩის შემოწმებას
• რეგულარული გამოხატულება
• . ეს ფუნქცია მხოლოდ პირველ მატჩს ეძებს! preg_match_all preg_quote - გაურბის სიმბოლოებს რეგულარულ გამონათქვამებში.
• იმათ. აყენებს ხაზებს ყველა სერვისის სიმბოლოს წინ (მაგალითად, ფრჩხილებში,
• კვადრატული ფრჩხილები
• და ა.შ.) ისე, რომ ისინი სიტყვასიტყვით არის აღებული. თუ თქვენ გაქვთ რაიმე მომხმარებლის შეყვანა და თქვენ ამოწმებთ მას რეგულარული გამონათქვამების გამოყენებით, მაშინ ჯობია, სანამ ამას გააკეთებთ, გაურბოდეთ სერვისის სიმბოლოებს შემომავალ ცვლადში.

preg_replace

preg_replace_callback - ასრულებს რეგულარული გამონათქვამების ძიებას და ჩანაცვლებას

preg_split

preg_grep

preg_grep ფუნქცია - აბრუნებს მოვლენების მასივს, რომელიც ემთხვევა შაბლონს

სინტაქსი

მასივი preg_grep (სტრიქონის ნიმუში, მასივის შეყვანა [, int flags])
preg_grep() აბრუნებს მასივს, რომელიც შედგება შეყვანის მასივის ელემენტებისაგან, რომლებიც ემთხვევა მოცემულ შაბლონს. flags პარამეტრს შეუძლია მიიღოს შემდეგი მნიშვნელობები: PREG_GREP_INVERT
თუ ეს დროშა დაყენებულია, preg_grep() ფუნქცია აბრუნებს მათ
მასივის ელემენტები

, რომლებიც არ ემთხვევა მოცემულ შაბლონს.

preg_grep()-ის მიერ დაბრუნებული შედეგი იყენებს იგივე ინდექსებს, როგორც ორიგინალური მონაცემთა მასივი. თუ ეს ქცევა არ შეესაბამება თქვენ, გამოიყენეთ array_values() preg_grep()-ის მიერ დაბრუნებულ მასივზე ხელახალი ინდექსისთვის.

კოდის ნიმუში:

preg_split

// აბრუნებს მასივის ყველა ელემენტს // შეიცავს მცურავი წერტილის ნომრებს $fl_array = preg_grep("/^(\d+)?\.\d+$/", $array);

preg_match preg_match ფუნქცია - ასრულებს მატჩს რეგულარულ გამონათქვამთანმითითებულია მატჩები, ის შეივსება ძიების შედეგებით. $matches ელემენტი შეიცავს სტრიქონის ნაწილს, რომელიც ემთხვევა მთელ შაბლონს, $matches შეიცავს სტრიქონის იმ ნაწილს, რომელიც ემთხვევა პირველ ქვეპატერნს და ა.შ.

დროშებს შეუძლიათ მიიღონ შემდეგი მნიშვნელობები:

PREG_OFFSET_CAPTURE

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

preg_match() ფუნქცია აბრუნებს ნაპოვნი შესატყვისების რაოდენობას. ეს შეიძლება იყოს 0 (შემთხვევა არ მოიძებნა) ან 1, რადგან preg_match() წყვეტს მუშაობას პირველივე ნაპოვნის შემდეგ. თუ თქვენ გჭირდებათ ყველა შესატყვისის პოვნა ან დათვლა, უნდა გამოიყენოთ preg_match_all() ფუნქცია. preg_match() ფუნქცია აბრუნებს FALSE-ს, თუ რაიმე შეცდომა მოხდება შესრულების დროს.

რეკომენდაცია: არ გამოიყენოთ preg_match() ფუნქცია, თუ თქვენ გჭირდებათ ქვესტრინგის არსებობის შემოწმება მოცემულ სტრიქონში. ამისათვის გამოიყენეთ strpos() ან strstr(), რადგან ისინი უფრო სწრაფად შეასრულებენ დავალებას.

მაგალითი კოდი მაგალითი კოდი მაგალითი კოდი მაგალითის შედეგი:

დომენის სახელია: საიტი

preg_match_all

preg_match_all ფუნქცია - ასრულებს გლობალური ნიმუშის ძიებას სტრიქონში

preg_split

int preg_match_all (სტრიქონის ნიმუში, სტრიქონის თემა, მასივის შესატყვისები [, int flags [, int offset]])

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

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

არასავალდებულო დროშების პარამეტრს შეუძლია გააერთიანოს შემდეგი მნიშვნელობები (გაითვალისწინეთ, რომ PREG_PATTERN_ORDER-თან ერთად PREG_SET_ORDER-ის გამოყენება უაზროა):

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

მაგალითის კოდი მაგალითის შედეგი: მაგალითი: , ეს არის ტესტის მაგალითი: , ეს არის ტესტი

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

PREG_SET_ORDER
თუ ეს დროშა დაყენებულია, შედეგი დალაგდება შემდეგნაირად: $matches ელემენტი შეიცავს მოვლენების პირველ კომპლექტს, $matches ელემენტი შეიცავს მოვლენების მეორე კომპლექტს და ა.შ.

მაგალითის კოდი მაგალითის შედეგი: მაგალითი: , მაგალითი: ეს არის ტესტი, ეს არის ტესტი

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

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

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

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

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

მაგალითის კოდი მაგალითის კოდი მაგალითის შედეგი: შესატყვისი: თამამი ტექსტი ნაწილი 1: ნაწილი 2: თამამი ტექსტი ნაწილი 3: შესატყვისი: დააწკაპუნეთ მენაწილი 1: ნაწილი 2: დააწკაპუნეთ მე ნაწილი 3: preg_quote

preg_quote ფუნქცია - გაურბის სიმბოლოებს რეგულარულ გამონათქვამებში

preg_split

string preg_quote (სტრიქონის str [, სტრიქონის გამიჯვნა])

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

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

რეგულარულ გამონათქვამებში შემდეგი სიმბოლოები განიხილება სერვისის სიმბოლოებად: . \\ + * ? [ ^ ] $ () ( ) = !< > | :

მაგალითი კოდი მაგალითის კოდი მაგალითის შედეგი: ეს წიგნი არის *ძალიან*ძნელი საპოვნელი. preg_replace

preg_replace ფუნქცია - ახორციელებს ძიებას და ჩანაცვლებას რეგულარული გამოხატვის გამოყენებით

preg_split

შერეული preg_replace (შერეული ნიმუში, შერეული ჩანაცვლება, შერეული თემა [, int ლიმიტი])

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

ჩანაცვლება შეიძლება შეიცავდეს \\n ფორმის მითითებებს ან (PHP 4.0.4-დან) $n, სასურველია ეს უკანასკნელი. ყოველი ასეთი მითითება შეიცვლება ფრჩხილებში ჩასმული n-ის ქვესტრიქონით, რომელსაც შეუძლია მიიღოს მნიშვნელობები 0-დან 99-მდე, ხოლო მითითება \\0 (ან $0) შეესაბამება მთელი ქვენიმუშების არსებობას დანომრილია მარცხნიდან მარჯვნივ, დაწყებული ერთით.

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

მაგალითი კოდი

ამ მაგალითის შედეგი იქნება:

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

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

შავი დათვი ნელი გადახტა ზარმაცი ძაღლს.

ksort()-ის გამოყენებით მივიღებთ სასურველ შედეგს:

ნელი შავი დათვი ზარმაცი ძაღლს გადაახტა.

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

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

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

კოდის ნიმუში: ჩანაცვლება მრავალი ნიმუშით

ეს მაგალითი გამოვა:

$startDate = "5/27/1999";

კოდის მაგალითი: /e მოდიფიკატორის გამოყენებით მაგალითის კოდი: ყველა HTML ტეგს გარდაქმნის დიდი ასოებით preg_replace_callback

preg_replace_callback ფუნქცია - ასრულებს რეგულარული გამონათქვამების ძიებას და ჩანაცვლებას გამოძახების ფუნქციის გამოყენებით

preg_split

შერეული preg_replace_callback (შერეული ნიმუში, უკუ გამოძახება, შერეული თემა [, int limit])

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

მაგალითი კოდი (.*?).")", $xml, $matches, PREG_PATTERN_ORDER);

$ მატჩების დაბრუნება; )

მოძებნეთ XHTML/XML ტეგები კონკრეტული ატრიბუტის მნიშვნელობით

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

ფუნქცია get_tag($attr, $value, $xml, $tag=null) ( if(is_null($tag)) $tag = "\w+"; სხვა $tag = preg_quote($tag); $attr = preg_quote($ attr $value = preg_quote($tag_regex = "/]*$attr\s*=\s*"; .*?)/" preg_match_all($tag_regex, $xml, $matches, PREG_PATTERN_ORDER); დააბრუნეთ $matches; )

კიდევ ერთი სასარგებლო ინსტრუმენტი ვებ დეველოპერებისთვის! ის საშუალებას გაძლევთ იპოვოთ/შეამოწმოთ თექვსმეტობითი ფერის მნიშვნელობები.

$string = "#555555"; if (preg_match("/^#(?:(?:(3))(1,2))$/i", $string)) (echo "მაგალითი 6 წარმატებული."; )

მოძებნეთ სტატიის სათაური

კოდის ეს ნაწყვეტი იპოვის და აჩვენებს ტექსტს ტეგების შიგნით html გვერდზე.

$fp = fopen("http://www.catswhocode.com/blog","r"); while (!feof($fp))($page .= fgets($fp, 4096); ) $titre = eregi("(.*)",$page,$regs); echo $regs; fclose ($fp);

Apache ჟურნალების გარჩევა

საიტების უმეტესობა მუშაობს ცნობილ Apache ვებ სერვერზე. თუ თქვენი საიტი ერთ-ერთი მათგანია, რატომ არ გამოიყენოთ PHP და რეგულარული გამონათქვამები Apache ჟურნალების გასაანალიზებლად?

//ლოგები: Apache ვებ სერვერი //წარმატებული ჰიტები მხოლოდ HTML ფაილებზე. სასარგებლოა გვერდის ნახვების რაოდენობის დასათვლელად. "^((?#კლიენტის IP ან დომენის სახელი)S+)s+((?#ძირითადი ავთენტიფიკაცია)S+s+S+)s+[((?#თარიღი და დრო)[^]]+)]s+"(?: GET|POST|HEAD) ((?#ფაილი)/[^ ?]+?.html?)??((?#პარამეტრები)[^ ?]+)? HTTP/+"s+(?#სტატუსის კოდი)200s+((?#ბაიტი გადაცემული)[-0-9]+)s+"((?#referrer)[^"]*)"s+"((?#მომხმარებლის აგენტი )[^"]*)"$" //Logs: Apache ვებ სერვერი //404 შეცდომები მხოლოდ "^((?#კლიენტის IP ან დომენის სახელი)S+)s+((?#ძირითადი ავთენტიფიკაცია)S+s+S+) s+[((?#თარიღი და დრო)[^]]+)]s+"(?:GET|POST|HEAD) ((?#ფაილი)[^ ?]+)??((?#პარამეტრები)[ ^?"]+)? HTTP/+"s+(?#სტატუსის კოდი)404s+((?#ბაიტი გადაცემული)[-0-9]+)s+"((?#referrer)[^"]*)"s+"((?#მომხმარებლის აგენტი )[^"]*)"$"

ორმაგი ციტატების შეცვლა ჭკვიანი ციტატებით

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

Preg_replace("B"b([^"x84x93x94rn]+)b"B", "?1?", $ტექსტი);

პაროლის ყოვლისმომცველი შემოწმება

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

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

"A(?=[-_a-zA-Z0-9]*?)(?=[-_a-zA-Z0-9]*?)(?=[-_a-zA-Z0-9]*?) [-_a-zA-Z0-9](6,)z"

WordPress: რეგულარული გამოხატვის გამოყენება პოსტიდან სურათების მისაღებად

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

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