#si", file_get_contents ("http://www.alexa.com/siteinfo/($url)"), $a); վերադարձի կտրվածք(str_replace(",","",strip_tags($a))); ) $alexa = alexa ($url); echo $alexa; ?>

4) Ստացեք և ցուցադրեք էջի անվանումը:

1 2 3 4 5

(.*)<\/title>/s" , $str , $m ) ; echo $m [ 1 ] ; ?>

(.*)<\/title>/s", $str, $m); echo $m; ?>

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

\n \r \t ]/", "" , $content ); // փոխարինելով նոր տողի և ներդիրի նիշերը բացատով$content = preg_replace ("/(2,)/" , " " , $content ); // փոխարինել ավելի քան 2 բացատ մեկով preg_match_all("/ ]*href=(?:"| \" )(.*)(?:"|\" )[^<>]*>(.*)<\/a>/iU», $բովանդակություն, $links ); // հավաքել հղումներ, եթե (sizeof ($links [ 1 ] ) > 0 ) // եթե գտնվեն հղումներ($out = զանգված() ; // արտաքին հղումների զանգված foreach ($links [1] որպես $v) ( if (preg_match ("/http:\/\/(www\.)(0,1)" . $domain. "/i", $v)) // ջնջել ներքին հղումները(շարունակություն ;) եթե (preg_match ( «/(http:|https:)?\/\/(www\.)(0,1)(.*)/i", $v )) // արտաքին հղում($out = $v;)) վերադարձնել $out; ) վերադարձի զանգված(); ) $domain = "կայք" ; $content = file_get_contents ("http://site/"); $getoutlinks = getoutlinks($content, $domain); համար ($i = 0; $i<= count ($getoutlinks ) ; $i ++ ) { echo $getoutlinks [ $i ] . " " ; } ?>

]*href=(?:"|\")(.*)(?:"|\")[^<>]*>(.*)<\/a>/iU», $content, $links); // հավաքել հղումներ, եթե (sizeof($links) > 0) // եթե հղումներ գտնվեն ( $out = array(); // արտաքին հղումների զանգվածը foreach ($links as $v ) ( if (preg_match("/http:\/\/(www\.)(0,1)".$domain."/i", $v)) // ջնջել ներքին հղումները (շարունակել; ) if (preg_match ("/(http:|https:)?\/\/(www\.)(0,1)(..com/"); $getoutlinks = getoutlinks($content, $domain); համար ( $i = 0;$i<= count($getoutlinks); $i++) { echo $getoutlinks[$i]."
"; } ?>

որտեղ:
preg_replace- Կատարում է որոնում և փոխարինում՝ օգտագործելով կանոնավոր արտահայտություն:
preg_match— ստուգում է կանոնավոր արտահայտության նկատմամբ:
preg_match_all- գտնում է բոլոր համընկնումները, մինչդեռ preg_match - միայն առաջինը:
file_get_contents- ստացեք ֆայլի բովանդակությունը մեկ տողով:
կտրել- Հեռացնում է տողի սկզբում և վերջում բացատները:
str_replace- փոխարինում է որոնման տողը փոխարինող տողով:
strip_tags- հեռացնում է html և php պիտակները տողից:
չափը- Ստանում է փոփոխականի տարրերի քանակը:
հաշվել- հաշվում է զանգվածի տարրերի թիվը կամ օբյեկտի հատկությունների քանակը:

) Ես ձեզ ցույց տվեցի կանոնավոր արտահայտություններ օգտագործելու օրինակ՝ էջի սկզբնական կոդի որոշակի հատվածներ գտնելու համար: Այժմ մենք կսովորենք, թե ինչպես գրել դրանք ինքներդ: Այս հմտությունը կօգնի ձեզ գրել, մաքրել տեքստը ավելորդ բեկորներից, փնտրել ճիշտ մասերը մեծ ծավալի տեքստում և այլն:

Այս թեման բավականին բարդ է, բայց ես կփորձեմ հակիրճ ընդգծել ամենակարևոր կետերը։ Չգիտեմ, թե ինչպես կհաջողվի, բայց հուսով եմ, որ դասը օգտակար կլինի։
Այսպիսով, եկեք սկսենք նրանից, որ PHP-ում կանոնավոր արտահայտությունների հետ աշխատելու մի քանի գործառույթ կա, բայց ամենից հաճախ օգտագործվում են երեքը.

• preg_replace - որոնել և փոխարինել տեքստը, որը համապատասխանում է կանոնավոր արտահայտությանը;
• preg_match - պարզապես սովորական արտահայտությունների որոնում;
• preg_split - որոնել և բաժանել տեքստը:

Համենայն դեպս, նախորդ դասերին մենք օգտագործել ենք դրանք։ Ավելի ճիշտ՝ preg_match-ի փոխարեն եղել է preg_match_all, բայց սա էապես նույնն է, միայն վերջինս չի ընդհատում որոնումը առաջին հայտնաբերումից հետո։ Այսինքն, եթե օգտագործենք preg_match, ապա չենք գտնի բոլոր երևույթները, այլ միայն առաջինը։

Ընտրել, թե որ իրավիճակում որ գործառույթն օգտագործել, բավականին պարզ է: Մենք պետք է փոխարինենք - մենք օգտագործում ենք փոխարինում, ինչպես այն դեպքում, երբ անհրաժեշտ էր հեռացնել էջի կոդի ավելորդ մասերը, հիշու՞մ եք:

$page = preg_replace("/ ^]/i", "", $էջ); $էջ = preg_replace ("/ ^]/i", "", $էջ); $էջ = str_replace ("", "", $էջ);

Ֆունկցիայի առաջին պարամետրը կանոնավոր արտահայտություն է, որը որոշում է, թե ինչ ենք փնտրում: Երկրորդն այն է, թե ինչով ենք այն փոխարինում։ Երրորդ - Որտե՞ղ ենք մենք փնտրում: Հետևաբար, այստեղ մենք վերցրել ենք $page փոփոխականը և նրան վերագրել ենք preg_replace ֆունկցիայի արդյունքը, որտեղ մենք փնտրել ենք բոլոր մուտքագրման type=checkbox, ինչպես նաև բացման և փակման պիտակները: Մենք դրանք փոխարինել ենք «»-ով, այսինքն՝ ուղղակի ջնջել են։ Հուսով եմ՝ այստեղ ամեն ինչ պարզ է։ Բուն արտահայտության վերլուծությանը (ֆունկցիայի առաջին պարամետրը) կանցնենք մի փոքր ուշ։
Նաև օրինակ կար՝ օգտագործելով preg_match_all, որը հարմար էր մնացած տեքստում բոլոր հղումները գտնելու համար: Այն ժամանակ մեզ անհրաժեշտ էին հղումներ, քանի որ դրանք պարունակում էին հիմնաբառեր, որոնք մենք վերլուծեցինք: Ահա թե ինչ է տեղի ունեցել.

Preg_match_all("/ ]+?>(.*?)<\/a>/uis",$page,$ok); համար ($j=0; $j «.$ok[$j]»:"; }

Կրկին, առաջին պարամետրը սովորական արտահայտություն է բոլոր հղումները գտնելու համար, որոնք, իհարկե, կցված են «a» պիտակի մեջ (եթե դուք ընկերներ չեք html նշագրման հետ, ապա կարդացեք այն): Երկրորդը փոփոխական է, որը պարունակում է փնտրվող տեքստը: Երրորդ պարամետրը փոփոխական է, որի մեջ դրված է արդյունքը՝ $ok: Դրանից հետո մնում է միայն անցնել $ok-ի բոլոր անհրաժեշտ տարրերը՝ մեզ անհրաժեշտ հիմնաբառերը ստանալու համար։ Առանձին-առանձին պետք է ասել, որ ելքում մենք ստանում ենք բազմաչափ զանգված։ Ահա թե ինչու մենք այն դուրս ենք բերում այդքան բարդ ձևով՝ $ok[$j]: Զանգվածի կառուցվածքը տեսնելու համար օգտագործեք ստորև նշված ֆունկցիան և ամեն ինչ կհասկանաք։

Print_r ($ok);

Այստեղ, կարծես, մենք պարզեցինք այն գործառույթները, որոնք մենք օգտագործել ենք աշխատանքի համար: Այժմ մնում է միայն սովորել, թե ինչպես գրել այս նույն կանոնավոր արտահայտությունները, որոնք այս մեթոդներից յուրաքանչյուրի առաջին պարամետրն են: Անցնենք ամենագլխավորին.

Ինչպես գրել կանոնավոր արտահայտություններ

Նախ, եկեք նայենք հիմնական կառույցներին: Արտահայտություններն ունեն տարբերակներ: Դրանք նշվում են մեկ տառով և գրվում են վերջում, նախորդում է շեղ:

Բացի այդ, աջակցվում են հետևյալ մետանիշերը.

Մետանիշերը, իրենց հերթին, կարող են փոփոխիչներ ունենալ.

Դե, հիմա կարող ենք անցնել վերջին դասի մեր կանոնավոր արտահայտությունների վերլուծությանը։ Ելնելով վերը նշված աղյուսակներից՝ փորձենք հասկանալ, թե ինչ ունենք։ Ահա արտահայտությունը.

/^]/i

Առաջին և վերջին «/» շեղերը ցույց են տալիս, որ դրանց ներսում կա կանոնավոր արտահայտություն։ Միևնույն ժամանակ, մենք դնում ենք «i»-ն վերջինից հետո, սա տարբերակ է, ինչպես առաջին աղյուսակում. Շեղերի ներսում ինքնին կանոնավոր արտահայտությունն է: Այն սկսվում է պակաս քան նշանով և մուտքային պիտակով, և դրանից հետո ամեն ինչ մինչև որոնման համար պարզ տեքստ լինի: Բայց ինքնին կետը և դրանից հետո հերոսները սա արդեն ավելի հետաքրքիր է: Այս դեպքում «.*? նշանակում է նիշերի ցանկացած հաջորդականություն: Այսինքն, եթե մենք համադրենք միայն տեքստը և այս կոնստրուկցիան, ապա մենք կընտրենք ամբողջ տեքստը առաջին դեպքից հետո և մինչև վերջ: Դադարեցնելու համար դուք պետք է հանդիպեք կամ փակվող html թեգին «մեծ քան» կամ նոր տողի նիշին: Այս դիզայնը մեզ ուղղակի այսպիսի հնարավորություն է տալիս.

Քառակուսի փակագծերի նիշերը, կարծես, միացված են տրամաբանական ԿԱՄ-ով: Վերջը նշանից մեծ է ԿԱՄ տողի սկիզբը:
Դա ամբողջ արտահայտությունն է, դրանում մենք սահմանում ենք սկզբի պայմանը, միջինը և վերջի պայմանը: Դժվար չէ, չէ՞: Ահա մի նկարազարդում ավելի պարզ դարձնելու համար.

Եկեք մի բան էլ բաժանենք, որպեսզի ամեն ինչ պարզ լինի: Մենք փնտրեցինք դրանց հղումները.

/]+?>(.*?)<\/a>/uis

Կարդում ենք արտահայտությունը. Կրկին, մենք նախ հրաժարվում ենք կտրվածքից և տարբերակներից: «uis» դրոշներն ինքնին բացատրելի են, բացառությամբ «u»-ի, որը ես չեմ նկարագրել. դա ցույց է տալիս, որ մենք օգտագործում ենք Unicode կոդավորումը: Շատ բան չի մնացել։ Սկիզբը «a» թեգն է, որը բացվում է, հետո գալիս է դասը

ինչը նշանակում է ՈՉ ավելի կամ պակաս (բացել և փակել html թեգերը), այսինքն՝ ցանկացած նիշ այս դեպքում։ Դասին ավելացվում է «+», ինչը նշանակում է, որ այս դասը ներկա կլինի 1 կամ ավելի անգամ (բայց առնվազն 1 անգամ հաստատ): Եվ հետո գալիս է փակվող html թեգը «a» թեգի համար: Հղման ներսում կա տեքստ, որը սահմանված է խմբի կողմից

Ի վերջո, մենք չգիտենք, թե ինչ տեքստ կլինի այնտեղ, ուստի մենք սահմանում ենք նման խումբ: Իսկ փակման թեգի «a» վերջում.

Նկատի ունեցեք, որ մենք շեղից դուրս ենք գալիս հետին կտրվածքով, որպեսզի այն պարզ տեքստի տեսք ունենա:

Ֆու Թեման իսկապես բավականին բարդ է, պրակտիկա է պահանջում։ Միգուցե ես ոչ այնքան օպտիմալ բան եմ անում, և դուք կարող եք կատարել այլ, ավելի ճիշտ կանոնավոր արտահայտություններ, բայց ես նույնքան ինքնուսույց եմ, որքան դուք, այնպես որ խիստ մի դատեք, այլ ավելի շուտ կիսվեք ձեր տարբերակները մեկնաբանություններում: Բացի այդ, եթե ինչ-որ բան պարզ չէ, մեկնաբանությունները և կոնտակտային էջը ձեր ծառայությանն են:

խառը preg_replace(խառը նախշ, խառը փոխարինում, խառը թեմա [, int limit])

Որոնում է թեման օրինաչափությունների համընկնումների համար և դրանք փոխարինում փոխարինողով: Եթե ​​սահմանային պարամետրը նշված է, ապա կաղապարի սահմանային դեպքերը կփոխարինվեն. եթե սահմանը բաց թողնվի կամ հավասար է -1-ի, ապա օրինաչափության բոլոր երևույթները կփոխարինվեն:

Փոխարինումը կարող է պարունակել \\ n ձևի հղումներ կամ (PHP 4.0.4-ի դրությամբ) $n, վերջինը նախընտրելի է: Յուրաքանչյուր նման հղում կփոխարինվի n-րդ փակագծով ենթապատկերին համապատասխանող ենթատողով: n-ը կարող է արժեքներ ընդունել 0-ից մինչև 99, հղումով \\0 (կամ $0) համապատասխանում է ամբողջ օրինաչափության առաջացմանը: Ենթապատկերները համարակալված են՝ ձախից աջ՝ մեկից սկսած:

Ենթապատկերի հղումների միջոցով նիշերի փոխարինում օգտագործելիս կարող է լինել այնպիսի իրավիճակ, երբ դիմակին անմիջապես հետևում է թվանշան: Այս դեպքում \\n նշումը հանգեցնում է սխալի. հղումը առաջին ենթապատկերին, որին հաջորդում է 1-ը, կգրվի որպես \\11 , որը կմեկնաբանվի որպես հղում տասնմեկերորդ ենթապատկերին: Այս թյուրիմացությունը կարելի է վերացնել՝ օգտագործելով \$(1)1 կոնստրուկցիան, որը ցույց է տալիս առաջին ենթապատկերի առանձին հղումը, որին հաջորդում է 1 թվանշանը:

Այս օրինակի արդյունքը կլինի.

Ապրիլ 1, 2003 թ

Եթե ​​ֆունկցիայի կատարման ժամանակ օրինաչափության համընկնում հայտնաբերվի, առարկայի փոփոխված արժեքը կվերադարձվի, հակառակ դեպքում՝ առարկայի բնօրինակ տեքստը կվերադարձվի:

Ֆունկցիայի առաջին երեք պարամետրերը preg_replace ()կարող են լինել միաչափ զանգվածներ: Եթե ​​զանգվածն օգտագործում է ստեղներ, ապա զանգվածը մշակելիս դրանք կվերցվեն այն հերթականությամբ, որով գտնվում են զանգվածում։ Նմուշի և փոխարինման համար զանգվածում ստեղների նշելը պարտադիր չէ: Եթե ​​դեռ որոշել եք ինդեքսներ օգտագործել, օգտագործեք ֆունկցիան՝ փոխարինման մեջ ներգրավված նախշերը և տողերը համապատասխանելու համար: ksort ()զանգվածներից յուրաքանչյուրի համար:

Օրինակ 2. Թվային ինդեքսներով զանգվածների օգտագործումը որպես ֆունկցիայի փաստարկներ preg_replace () $string = «Արագ շագանակագույն աղվեսը ցատկեց ծույլ շան վրայով»։;$patterns [ 0 ] = "/quick/" ; $patterns [1] = "/շագանակագույն/" ; $patterns [ 2 ] = "/fox/" ;$replacements [ 2 ] = " արջ " ; $replacements [ 1 ] = "սեւ" ; $replacements [ 0 ] = "դանդաղ" ;preg_replace ($patterns, $replacements, $string); ?> Արդյունք: Արդյունք: Դանդաղ սև արջը ցատկեց ծույլ շան վրայով։

Եթե ​​առարկայի պարամետրը զանգված է, ապա դրա յուրաքանչյուր տարրի համար կատարվում է օրինաչափության որոնում և փոխարինում: Վերադարձված արդյունքը նույնպես կլինի զանգված:

Այն դեպքում, երբ պարամետրերի օրինակը և փոխարինումը զանգվածներ են, preg_replace ()հերթով հանում է զույգ տարրեր երկու զանգվածից և օգտագործում դրանք որոնման և փոխարինման գործողության համար: Եթե ​​փոխարինող զանգվածը պարունակում է ավելի շատ տարրեր, քան օրինակը, ապա փոխարինման համար բացակայող տարրերի փոխարեն կվերցվեն դատարկ տողեր: Եթե ​​նախշը զանգված է, իսկ փոխարինումը` տող, ապա նախշի յուրաքանչյուր տարր կփնտրվի և կփոխարինվի նախշով (նախշը իր հերթին կլինեն զանգվածի բոլոր տարրերը, մինչդեռ փոխարինող տողը մնում է ֆիքսված): Ընտրանքը, երբ նախշը տող է, իսկ փոխարինումը զանգված է, իմաստ չունի:

/e փոփոխիչը փոխում է ֆունկցիայի վարքագիծը preg_replace ()այնպես, որ փոխարինման պարամետրը, անհրաժեշտ փոխարինումները կատարելուց հետո, մեկնաբանվի որպես PHP կոդ և միայն այնուհետ օգտագործվի փոխարինման համար։ Այս փոփոխիչն օգտագործելիս զգույշ եղեք. փոխարինման պարամետրը պետք է պարունակի վավեր PHP կոդ, հակառակ դեպքում ֆունկցիայի կանչը պարունակող տողում preg_replace (), կառաջանա շարահյուսական սխալ։

Օրինակ 3. Փոխարինել մի քանի նախշերով $patterns = զանգված ( "/(19|20)(\d(2))-(\d(1,2))-(\d(1,2))/", "/^\s*((\w+))\s*=/" ); $replace = array ("\\3/\\4/\\1\\2", "$\\1 ="); echo preg_replace ($patterns, $replace, "(startDate) = 1999-5-27" ); ?> Այս օրինակը կարտադրի. Փոխակերպում է բոլոր HTML թեգերը մեծատառերի

Օրինակ 5. HTML-ից տեքստ փոխարկիչ // $document ելքը պետք է պարունակի HTML փաստաթուղթ: // Պետք է հեռացնել բոլոր HTML պիտակները, javascript բաժինները, // բացատ նիշեր. Անհրաժեշտ է նաև մի քանիսը փոխարինել // HTML սուբյեկտները իրենց համարժեքին:$որոնում = զանգված( ""]*?>.*?«սի», // Կտրել javaScript-ը ""<[\/\!]*?[^<>]*?>«սի» , // Շերտավորում է HTML պիտակները ""([\r\n])[\s]+"" , // Շերտավորում է բացատ նիշերը ""&(quot|#34);"i" , // Փոխարինում է HTML սուբյեկտները ""&(amp|#38);"i" , ""&(lt|#60);"i" , ""&(gt|#62);"i" , ""&(nbsp|#160);"i" , ""&(iexcl|#161);"i" , ""&(cent|#162);"i" , ""&(ֆունտ|#163);"i" , ""&(պատճեն|#169);"i" , ""(\d+);"e"); // մեկնաբանել որպես php կոդ$replace = զանգված("" , "" , "\\1" , "\"" , "&" , "<" , ">" , " " , chr (161), chr (162), chr (163), chr(169), "chr(\\1)" );$text = preg_replace ($search, $replace, $document); ?>

PHP regexp-ը օրինաչափությունների համապատասխանող հզոր ալգորիթմ է, որը կարող է կատարվել մեկ հայտարարության մեջ: PHP-ի կանոնավոր արտահայտությունները օգտագործում են թվաբանական օպերատորներ (օրինակ՝ +, -, ^ ) բարդ արտահայտություններ ստեղծելու համար։

Ինչի համար են օգտագործվում կանոնավոր արտահայտությունները.

• Կանոնավոր արտահայտությունները հեշտացնում են լարային տվյալների նույնականացումը՝ կանչելով մեկ ֆունկցիա: Սա խնայում է ժամանակը կոդը գրելիս;
• Օգտագործողի կողմից մուտքագրված տվյալները ստուգելիս, ինչպիսիք են էլ.փոստի հասցեն, կայքի տիրույթը, հեռախոսահամարը, IP հասցեն;
• Որոնման արդյունքներում հիմնաբառերի ընդգծում;
• Կանոնավոր արտահայտությունները կարող են օգտագործվել պիտակները հայտնաբերելու և դրանք փոխարինելու համար:

Կանոնավոր արտահայտություններ PHP-ում

PHP-ն պարունակում է ներկառուցված գործառույթներ, որոնք թույլ են տալիս աշխատել կանոնավոր արտահայտությունների հետ: Այժմ եկեք դիտարկենք սովորաբար օգտագործվող PHP կանոնավոր արտահայտությունների գործառույթները:

• preg_match-ն օգտագործվում է տողի վրա օրինաչափությունների համապատասխանեցում կատարելու համար: Այն վերադարձնում է true, եթե համընկնում է գտնվել, և false, եթե համընկնում չի գտնվել;
• preg_split - օգտագործվում է տողը ըստ օրինաչափության բաժանելու համար, արդյունքը վերադարձվում է որպես թվային զանգված;
• preg_replace - օգտագործվում է օրինաչափությամբ որոնելու և նշված տողով փոխարինելու համար:

Ստորև բերված է սովորական արտահայտությունների ֆունկցիաների շարահյուսությունը, ինչպիսիք են preg_match, preg_split կամ PHP regexp փոխարինում.

«function_name»-ը կամ preg_match է, կամ preg_split, կամ preg_replace:
«/.../» - շեղերը նշում են կանոնավոր արտահայտության սկիզբը և վերջը:
«'/pattern/"»-ն այն օրինաչափությունն է, որը մենք պետք է համապատասխանենք:
«օբյեկտը» այն տողն է, որի հետ պետք է համապատասխանեցվի նախշը:

Այժմ դիտարկենք վերը նշված գործառույթների օգտագործման գործնական օրինակները։

Preg_match

Առաջին օրինակը օգտագործում է preg_match ֆունկցիան՝ տվյալ URL-ում գուրու բառի վրա պարզ օրինաչափության համընկնում կատարելու համար:

Ստորև բերված կոդը ցույց է տալիս այս օրինակի իրականացումը.

Դիտարկենք կոդի այն մասը, որը պատասխանատու է արդյունքի համար "preg_match('/guru/', $my_url)".

«preg_match(...)»-ը PHP համընկնման regexp ֆունկցիան է:
«'/Guru/"»-ը սովորական արտահայտությունների օրինակ է:
«$My_url»-ը փոփոխական է, որը պարունակում է համապատասխան տեքստ:

preg_split

Դիտարկենք մեկ այլ օրինակ, որն օգտագործում է preg_split ֆունկցիան:

Մենք կվերցնենք արտահայտությունը և այն կբաժանենք զանգվածի. նախշը նախատեսված է մեկ տարածություն փնտրելու համար.

Preg_replace

Դիտարկենք preg_replace ֆունկցիան, որը կատարում է օրինաչափության համընկնում և գտնված արդյունքը փոխարինում է մեկ այլ տողով։

Ստորև բերված կոդը փնտրում է գուրու բառը տողի մեջ: Այն փոխարինում է այն css կոդով, որը սահմանում է ֆոնի գույնը.

Գուրու", $text); echo $text; ?>

Մետանիշեր

Վերոնշյալ օրինակները օգտագործում էին պարզ ձևանմուշներ: Մետանիշերը թույլ են տալիս ավելի բարդ PHP regexp օրինաչափությունների համընկնում, օրինակ՝ էլփոստի հասցեի վավերացում: Դիտարկենք սովորաբար օգտագործվող մետանիշերը:

մետանիշ	Նկարագրություն	Օրինակ
.	Համապատասխանում է ցանկացած առանձին նիշի, բացառությամբ նոր տողի նիշի:	/./ - ամեն ինչ, որը պարունակում է մեկ նիշ:
^	Ցույց է տալիս տողի սկիզբը՝ չներառելով / նիշը:	/^PH/ ցանկացած տող է, որը սկսվում է PH-ով:
$	Նշանակում է նախշը տողի վերջում:	/com$/ - guru99.com, yahoo.com և այլն:
*	Ցույց է տալիս ցանկացած թվով նիշ՝ զրո կամ ավելի:	/com*/ - համակարգիչ, հաղորդակցություն և այլն:
+	Պահանջվում է առնվազն մեկ անգամ մետանիշ (նիշերի) նախորդում:	/yah+oo/ - yahoo.
	Վահանի խորհրդանիշ.	/yahoo+.com/ - կետը վերաբերվում է որպես բառացի արժեք:
[…]	Նիշերի դաս.	// - abc.
ա-զ	Նշում է փոքրատառերը:	/a-z/ - զով, ուրախ և այլն:
Ա-Զ	Նշում է մեծատառերը:	/Ա-Զ/ - Ի՞ՆՉ, ԻՆՉՊԵՍ, ԻՆՉՈՒ և այլն:
0-9	Նշում է 0-ից 9-ը ցանկացած թվեր:	/0-4/ — 0,1,2,3,4.

Այժմ եկեք նայենք բարդ PHP regexp օրինակին, որը ստուգում է, արդյոք էլփոստի հասցեն վավեր է.

Արդյունք՝ էլփոստի հասցե [էլփոստը պաշտպանված է]վավեր է.

Կաղապարի բացատրություն» [էլփոստը պաշտպանված է]+.(2,5)$/]"

«'/…/»» սկսում և ավարտում է կանոնավոր արտահայտությունը:
«^»-ը համընկնում է ցանկացած փոքրատառ կամ մեծատառ, 0-ից 9 թվերի և կետերի, ընդգծումների կամ գծիկների հետ:
« [էլփոստը պաշտպանված է]'-ը համապատասխանում է @ նիշին, որին հաջորդում են փոքրատառերը կամ մեծատառերը, 0-ից 9-ը թվերը կամ գծիկները:
«+.(2,5)$/»-ը ցույց է տալիս մի կետ, որն օգտագործում է հետնագիծ, որին հաջորդում է ցանկացած փոքրատառ կամ մեծատառ, տողի վերջում նիշերի թիվը պետք է լինի 2-ից 5-ի միջև:

Կանոնավոր արտահայտությունները շատ հզոր, բայց միևնույն ժամանակ դժվար հասկանալի լարերի մշակման գործիք են: Ես նկարագրելու եմ հիմնական կետերը. Կանոնավոր արտահայտությունը լարային օրինակ է: Ըստ այս կաղապարի, դուք կարող եք որոնել երևույթներ, կատարել փոխարինում, ստուգել կաղապարի համապատասխանությունը։

Կաղապար (նախշ) կազմելու կանոններ

Նախշերի սահմանները պետք է նշվեն որոշակի նիշերով, հաճախ օգտագործելով « / «, բայց ես նախընտրում եմ օգտագործել» # «Որովհետև առջևի/հետևի թեքությունների առատությունը կարող է լիցքավորվել աչքերում, և «վանդակները» սովորաբար այլուր չեն օգտագործվում: Այսպիսով. #HereRegularExpressionBody#"

Կանոնավոր արտահայտության ներսում օգտագործվում են փակագծեր. սրանք ենթարտահայտություններ են, որոնք կարող են շահարկվել, օրինակ.

#^/catalog/(+)/(+)\.html.*#

Այս արտահայտությունը նախատեսված է պարամետրեր ստանալու համար URL. Տողի սկզբում կա հատուկ նիշ. ^ «- սա նշանակում է տողի սկիզբ: Հաջորդը գալիս է»: /կատալոգ/- այստեղ հատուկ նիշեր չկան, դա պարզապես տեքստ է, որը պետք է պարունակվի տողում: Հետո հանդիպեցինք փակագծեր, այսինքն՝ հասանք առաջին ենթաարտահայտմանը: Քառակուսի փակագծերը ցույց են տալիս այն նիշերի բազմությունը, որը կարող է լինել տողում: այս վայրը: Ստորագրեք - «Նշանակում է թվարկում։ Նշան». \ «փախչում է հատուկ նիշերից: Այսպիսով, առաջին ենթաարտահայտման մեջ մենք կարող ենք ունենալ լատինատառ այբուբենի ՄԵԾ և փոքր տառեր, թվեր 0-ից 9-ը, ընդգծում, գծիկ և կետ: Նկարը և կետը հատուկ նիշեր են, բայց այստեղ դրանք փախել են, ուստի այստեղ ընդամենը նիշերն են: Քառակուսի փակագծերից հետո գալիս է նշանը « + - սա նշանակում է, որ նախորդ նիշը (և մենք ունենք քառակուսի փակագծերում տրված նիշերի այս հավաքածուն) կարող է գնալ 1 կամ ավելի անգամ: Հետո գալիս է: / «ուղղակի կերպար է, և նմանատիպ երկրորդ ենթարտահայտում: Հետո գալիս է» \.html«ինչը նշանակում է տեքստը» .html«Եվ հետո հատուկ կերպարներ» .* «Կետը նշանակում է ցանկացած նիշ, իսկ աստղանիշը նախորդ նիշի ցանկացած թիվ: Այսինքն՝ հետո»: .html«Ամեն ինչ կարող է գնալ.

Նշելով քանակություն, քանակականներ

Վերևում մենք արդեն դիտարկել ենք այնպիսի խորհրդանիշներ, որոնք ցույց են տալիս նախորդ նշանների քանակը, ինչպիսիք են + և * . Ահա քանակությունը նշելու բոլոր հնարավորությունները.

Հատուկ կերպարներ

Որոշ նիշերի խմբերի համար կան հատուկ հապավումներ.

«Ագահություն»

Դիտարկենք կանոնավոր արտահայտման ագահության հայեցակարգը: Օրինակ կա մի տող.

#()#

Ընթերցանություն՝ ենթաարտահայտում.

Ամեն ինչ կարծես թե ճիշտ է, ենթաարտահայտությունը տեղավորվում է հետևյալում.

Բայց դա նաև տեղավորվում է.

Մենք դա կստանանք, քանի որ. կանոնավոր արտահայտությունները լռելյայն «ագահ» են: Դուք կարող եք հեռացնել ագահությունը փոփոխիչի միջոցով U", սրա նման:

#() #U

Փոփոխիչներ

Կանոնավոր արտահայտություններին կարող են հետևել փոփոխիչներ. #HereRegularExpressionBody#HereModifiers«Փոփոխիչների տեսակները.

ես	Միացնում է մեծատառերի անզգայուն ռեժիմը, այսինքն. արտահայտության մեջ մեծ և փոքր տառերը չեն տարբերվում.
մ	Ցույց է տալիս, որ որոնվող տեքստը պետք է դիտարկվի որպես մի քանի տող: Լռելյայնորեն, սովորական արտահայտությունների շարժիչը տեքստը վերաբերվում է որպես մեկ տող, անկախ նրանից, թե իրականում ինչ է: Համապատասխանաբար, մետանիշեր «^» և «$»նշեք ամբողջ տեքստի սկիզբը և վերջը: Եթե ​​նշված է այս փոփոխիչը, ապա դրանք ցույց կտան համապատասխանաբար տեքստի յուրաքանչյուր տողի սկիզբը և վերջը:
ս	Կանխադրված մետանիշն է « . «Նոր տողի նիշը չի ներառում իր սահմանման մեջ: Այս փոփոխիչի նշումը վերացնում է այս սահմանափակումը:
U	Հեռացնում է սովորական արտահայտության ագահությունը
u	Թույլ է տալիս աշխատել կանոնավոր արտահայտությունների հետ Կիրիլիցա մինչև UTF-8հակառակ դեպքում այն ​​ճիշտ չի աշխատում:

php ֆունկցիաներ՝ կանոնավոր արտահայտությունների հետ աշխատելու համար

preg_replace

Որոնել և փոխարինել.

preg_replace (խառը $pattern, խառը $փոխարինում, խառը $subject [, int $limit = -1 [, int &$count ]]);

Յուրաքանչյուր արժեք կարող է լինել տող կամ զանգված, դեպքում $թեմազանգված - վերադարձվում է զանգված, հակառակ դեպքում՝ տող

preg_split

Տողը բաժանում է կանոնավոր արտահայտությամբ.

preg_split(string $pattern, string $subject [, int $limit = -1 [, int $flags = 0 ]]);

Վերադարձնում է զանգված, որը բաղկացած է տվյալ տողի ենթատողերից առարկա, որը բաժանված է օրինաչափությանը համապատասխանող սահմանների երկայնքով օրինակը.