Մենյու
տունՀեռուստացույց և վիդեո

Վեբ էջի վերլուծություն և մշակում PHP-ով. ընտրել լավագույն գրադարանը: Ֆայլի ընթերցում PHP-ում Ընտրելով լավագույն տարբերակը php տողի վերլուծություն

Հրապարակման ամսաթիվ՝ 03.01.2018թ

Ողջույններ, ընկերներ: 🙂

Կարծում եմ, որ, եթե ոչ բոլորը, ապա, իհարկե, ձեզանից շատերը գործնականում հանդիպել են տեղեկատվությունը կարդալու անհրաժեշտությանը txt ֆայլերսերվերի սկրիպտների մակարդակով։ Ես, համենայնդեպս, նման մի քանի դեպք եմ ունեցել, որոնցից վերջինը կպատմեմ այսօր։

Սրա մեջ բարդ բան չկա, բայց երբեմն աչքերը բացվում են սերվերի լեզուների միջոցով տրամադրվող տարբերակների առատությունից։ Խոսելով կոնկրետ PHP-ի մասին, որում ես ներկայումս ծրագրավորում եմ, օգտագործելով դրա գործառույթները, կարող եք կարդալ ֆայլերի բովանդակությունը տող առ տող, և ամբողջությամբ տողի մեջ, և զանգվածի մեջ, իսկ վերջին տարբերակի համար կան ևս մի քանի եղանակներ. Սրանք կարկանդակներն են 🙂

Ցավոք սրտի, այս մեթոդներն աշխատում են տարբեր արագությամբ տարբեր կառույցների ֆայլերի համար, և պաշտոնական փաստաթղթերում դրանց աշխատանքի արագության մասին ոչ մի խոսք չկա. սա կարելի է դատել միայն գործնականում` դասակարգելով բոլոր հնարավոր տարբերակները:

Ուստի այսօր ես ձեզ ցույց կտամ աշխատանքը տարբեր գործառույթներ PHP ֆայլեր կարդալու համար, որպեսզի երբ դուք պետք է ստեղծեք PHP ֆայլերի վերլուծիչ իրական աշխարհի առաջադրանքների համար, իմանաք, թե ինչից ընտրել: Եվ ես ձեզ նաև հստակ կասեմ, թե ինչպես ճիշտ ընտրություն կատարել «մարտական ​​պայմաններում»:

Գնա՛ 🙂

PHP ֆայլի վերլուծիչի ստեղծում - սկզբնական պայմաններ

Նախքան սկսելը, մի քանի խոսք այն առաջադրանքի մասին, որի համար PHP-ում ստեղծեցի ֆայլերի վերլուծիչ, այնուհետև իրականացված տարբերակներից ընտրեցի օպտիմալը։

Մի անգամ ես աշխատավայրում խնդիր ունեի, որը բաղկացած էր նրանից, որ օգտատերերի հեռախոսահամարները տվյալների բազայում պահվում էին սխալ ձևաչափով: Սխալն ինքնին, իհարկե, ես շտկեցի առանց խնդիրների:

Բայց ի՞նչ անել ոչ ճիշտ տեղեկատվության հետ, որն այն ժամանակ արդեն պահվում էր տվյալների բազայում։ Բնականաբար, այն պետք է փոխարինվեր ճիշտով։

Դրա համար ինձ տրվեց տեքստային ֆայլօգտագործողների ID-ներով և նրանց հեռախոսներով, որոնք պետք է փոխանցվեին տվյալների բազա:

Պետք է ասեմ, որ բավականին ծանրակշիռ ստացվեց՝ 352 ԿԲ և 8223 տող տեքստ, որոնցից յուրաքանչյուրը պարունակում էր օգտատիրոջ ID-ն և նրա հեռախոսահամարը ձևաչափով։ user_id: phone_number.

Մի խոսքով, ամբողջ խնդիրը ֆայլը տող առ տող կարդալն էր PHP նշանակում է, նույնացուցիչը և հեռախոսը հանելով տողից, որին հաջորդում է ID-ի կողմից հայտնաբերված տվյալների բազայում օգտագործողի հեռախոսի արժեքի թարմացումը:

Իմ նախագիծն իրականացվել է PHP Yii շրջանակում, հետևաբար, կոդերի հետագա օրինակներում դուք կհանդիպեք դրա API-ի տարրերին՝ մասնավորապես տվյալների բազայի հետ աշխատելու համար, այնպես որ մի վախեցեք 🙂

Լեզուում առկա կոնստրուկցիաները, ինչպես նաև այլ ծրագրավորողների փորձը վերլուծելով համացանցում փոքր-ինչ հավաքագրված, ինձ հաջողվեց առանձնացնել 4 մեթոդ, որոնք կցուցադրեմ ձեզ ավելի ուշ։

Դե, դրանից հետո կասեմ, թե ինչ չափանիշներով և ինչպես եմ ընտրել դրանցից լավագույն տարբերակ. Եվ, իհարկե, ես կկիսվեմ արդյունքներով 🙂

Այսպիսով, այս հոդվածը համբերության հիանալի վարժություն է 🙂 Դրա էությունը կլինի մանրամասն ուսումնասիրել հետևյալ նյութը մինչև այն արդյունքները, որոնք ձեզ կսպասեն վերջում: Ճանապարհին, ի դեպ, կարող եք աշխատել նաև ձեր երևակայության վրա՝ ենթադրելով, թե կոնկրետ ինչպես կընտրվի իդեալական տարբերակը։

PHP-ում ֆայլի տող առ տող կարդալ fgets()

Արդյունքում՝ PHP ֆայլերի վերլուծիչ, որն իրականացնում է այս ալգորիթմը, ես վերցրեցի հետևյալ ձևը.

find("unique_id IN (:id1, :id2)", array(":id1" => strtolower($params), ":id2" => strtoupper($params))); if ($client) ( $client->phone = str_replace(array("\r", "\n"), "", $params); $client->save(); ) ) ) ) if (!feof ($fh)) ( echo "Սխալ. անսպասելի fgets() fail\n"; ) fclose($fh); ) else echo «Ստուգեք ֆայլի անունը, ֆայլը գոյություն չունի»;)

Ես մի փոքր կվերծանեմ իմ խզբզոցը, եթե ինչ-որ մեկը դժվարանում է հասկանալ:

Հենց սկզբում փոփոխականը $filenameվերագրվում է վերլուծվող ֆայլի անվան արժեքը՝ դրան տանող ամբողջական ուղով: Դրան հաջորդում է PHP-ն ստուգում է ֆայլի առկայությունը և արդյոք այն ընթեռնելի է ֆունկցիաների միջոցով file_exists ()և is_readable ()համապատասխանաբար.

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

Եթե ​​ֆայլը հաջողությամբ բացվել է, ապա մենք շրջագծով անցնում ենք նրա բոլոր տողերը, մինչև ֆայլը ավարտվի, իսկ եթե տողը դատարկ չէ, այն ֆունկցիայի հետ բաժանում ենք երկու կետով: պայթել ().

Այնուհետև ստուգում ենք, որ օգտատիրոջ id-ը և նրա հեռախոսը դատարկ չեն, տվյալների բազայում փնտրում ենք օգտագործողին ըստ id-ի, և եթե այն կա, ապա թարմացնում ենք հեռախոսահամարը նրա համար՝ հանելով գծիկն ու նոր տողի սկիզբը համարից։ արժեքը։

Դե, ես օգտագործել եմ նաև PHP ֆունկցիաներ strtolower ()և strtoupper ()ստուգել տվյալների բազայում օգտագործողի առկայությունը նույնացուցիչներով, որոնք կարող են գրվել տարբեր ռեգիստրներում, քանի որ դրանք իմ դեպքում բաղկացած էին խորհրդանիշներից և թվերից:

PHP-ն վերլուծում է ֆայլը զանգվածի մեջ՝ օգտագործելով file()

PHP-ում ֆայլը կարդալու այս մեթոդը ներառում է ֆունկցիայի օգտագործումը ֆայլ (), որը բացում է ֆայլը և տեղադրում դրա բովանդակությունը զանգվածի մեջ: Այս դեպքում զանգվածի տարրերը կլինեն միայն ընթերցվող ֆայլի տողերը, ինչը հիանալի է իմ իրավիճակում։

PHP ֆայլերի վերլուծիչի այս տարբերակի կոդը հետևյալն է.

find ("unique_id IN (:id, :id2)", array(":id" => strtolower($params), ":id2" => strtoupper($params))); if ($client) ($client->phone = str_replace(array("\r", "\n"), "", $params); $client->

Ինչպես տեսնում եք, սա տարբերվում է PHP-ում ֆայլը կարդալու նախորդ եղանակից միայն սկզբում, որտեղ ֆայլը բացվում և անմիջապես ընթերցվում է ֆունկցիայի միջոցով: ֆայլ ()փունջի փոխարեն fopen () + fgets (), ինչպես նախկինում։

PHP-ն ընթերցում է ֆայլը փոփոխականում՝ օգտագործելով fread()

Մեկ այլ PHP ֆունկցիա՝ ֆայլը վերլուծելու համար fread (), որի միջոցով կարող եք կարդալ որոշակի երկարության ֆայլի տարբեր հատվածներ: Ամբողջ ֆայլը PHP-ում կարդալու համար ես նշել եմ ֆայլի չափը, որը ստացվել է ֆունկցիայի միջոցով՝ որպես հատվածի չափ, որպես հատվածի չափ Ֆայլի չափ():

find("unique_id IN (:id1, :id2)", array(":id1" => strtolower($params), ":id2" => strtoupper($params))); if ($client) ( $client->phone = str_replace(array("\r", "\n"), "", $params); $client->save(); ) ) ) ) ) else echo " Ստուգեք ֆայլի անունը, ֆայլը գոյություն չունի»:)

Ընթերցանության այս ձևը PHP ֆայլնշանակում է, ըստ էության, այն շատ նման է նախորդին, քանի որ, չնայած այն հանգամանքին, որ օգտագործելով PHP, ֆայլի տվյալները սկզբում կարդացվում են ոչ թե զանգվածի, այլ տողային փոփոխականի, այնուհետև այն վերածվում է զանգվածի: , որովհետեւ ավելի հեշտ է աշխատել, քան թելի հետ:

PHP-ում տողը զանգվածի վերածելու ամենահեշտ ձևը explode() ֆունկցիայի օգնությամբ է, որն այսօր արդեն օգտագործվում է որպես տարանջատիչ, որին փոխանցվել է տողի սկզբի նիշը։

Ստեղծեք PHP ֆայլերի վերլուծիչ՝ հիմնված file_get_contents ()

Դե, և վերջապես, ես որոշեցի իրականացնել PHP ֆայլերի վերլուծություն՝ օգտագործելով ֆունկցիան file_get_contents (), որը պարզապես նախատեսված է ամբողջ ֆայլը տողի մեջ կարդալու համար, այսինքն. աշխատում է գրեթե նման fread ($fp, ֆայլի չափ ($filename)).

Միակ բացառությունն այն է, որ file_get_contents()-ն ինքն է բացում ֆայլը և կարդում այն, մինչդեռ fread()-ի միջոցով պետք էր նախ բացել ֆայլը fopen()-ով և ստանալ դրա ցուցիչը հետագա օգտագործման համար:

Ընդհանուր առմամբ, file_get_contents()-ի վրա հիմնված PHP ֆայլի վերլուծիչ կոդը գրեթե նույնն է լինելու, ինչ նախորդ դեպքում.

find("unique_id IN (:id1, :id2)", array(":id1" => strtolower($params), ":id2" => strtoupper($params))); if ($client) ( $client->phone = str_replace(array("\r", "\n"), "", $params); $client->save(); ) ) ) ) ) else echo " Ստուգեք ֆայլի անունը, ֆայլը գոյություն չունի»:)

Այսքանը: Ժամանակն է ամփոփելու վերը նշված բոլոր տարբերակների կատարումը և պարզելու, թե որ PHP ֆայլերի վերլուծիչն է առավել օպտիմալ հետագա օգտագործման համար:

Ո՞րն է PHP-ում ֆայլերը կարգավորելու լավագույն միջոցը:

Գտնված տարբերակներից ընտրել ամենաօպտիմալը, այսինքն. ամենաարագը, ես որոշեցի որոշել յուրաքանչյուր դեպքում: Դա անելու համար ես օգտագործեցի հոդվածում նկարագրված տեխնիկան հղումով:

Ինքնին, PHP ֆայլի ընթերցման գործառույթները բավականին արագ են, հետևաբար, որպեսզի հասնեմ դրանց շահագործման ժամանակի գոնե մի քանի քիչ թե շատ շոշափելի թվերի, ես միտումնավոր թողեցի տվյալների բազայի գործողությունները փորձարկված հատվածներում, որոնք բոլոր դեպքերում նույնն էին:

Հարմարության համար ես նաև որոշեցի կլորացնել PHP script-ի գործարկման ժամանակը մինչև երրորդ տասնորդական տեղը, այսինքն. վայրկյանի մինչև հազարերորդական (չնայած այն կարող էր սահմանափակվել հարյուրերորդականով, փաստորեն)։

Հիշում եմ, երբ դպրոցում էի և գրում էի ֆիզիկայի իմ գիտական ​​աշխատանքը (այո, այդպիսի փորձ կար 🙂) նրա պաշտպանության համար համալսարանի ուսուցիչների առջև, ինձ անընդհատ կշտամբում էին անբավարար քանակի փորձերի համար (յուրաքանչյուրի համար 3 ​​փորձ էի անում: դեպք): «Գիտության լույսերը» թվերն անվանեցին 100, լավ, կամ առնվազն 10 փորձ՝ տարբեր իրավիճակներ համեմատելու համար, որպեսզի կարողանաս ինչ-որ համեմատություն անել և նվազագույնի հասցնել մեկը մյուսի նկատմամբ պատահական գերազանցության հավանականությունը:

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

Դե, այս հոդվածում ես իմ ներկայիս փորձերում չեմ հավակնում գիտական ​​լինել, ուստի 100 փորձերի թիվը համարեցի անհարկի մեծ, իսկ դրանց անցկացման գործընթացը՝ հոգնեցուցիչ։

Արդյունքում, ես որոշեցի ինձ սահմանափակել 10 փորձով PHP ֆայլերի վերլուծիչի յուրաքանչյուր տարբերակի համար, ինչը, ինչպես պարզվեց, բավականին բավական էր՝ առանձնացնելու հստակ առաջատար՝ առանց փաստերի և հուշումների հարյուրերորդականների և հազարերորդականների համար: գերազանցության երկրորդ.

Իմ մշակած PHP ֆայլերի վերլուծիչների գործարկման ժամանակի հաշվարկների արդյունքները ներկայացված են հետևյալ աղյուսակում և դասավորված ըստ PHP ֆունկցիաների, որոնց վրա նրանք աշխատում են:

Փորձարկում fgets () ֆայլ () fread () file_get_contents ()
1 9,147 9,722 10,539 2,008
2 8,950 9,006 9,495 1,733
3 8,821 8,845 9,207 1,642
4 8,717 8,876 8,931 1,758
5 9,010 9,091 8,703 1,635
6 9,110 8,640 9,712 1,633
7 9,074 9,626 9,13 1,645
8 8,886 9,204 9,048 1,701
9 8,667 8,918 9,438 1,713
10 8,852 9,197 9,537 1,567
Միջին 8,923 9,113 9,374 1,704

Ինչպես տեսնում եք, 10 փորձերից յուրաքանչյուրում սցենարի կատարման ժամանակներից բացի, ես որոշեցի հաշվարկել միջին ջերմաստիճանը հիվանդանոցում 🙂

Մասնավորապես, յուրաքանչյուր PHP ֆայլի վերլուծիչի գործարկման ժամանակի միջին թվաբանականը, որպեսզի առաջատարը հնարավոր լինի նույնականացնել։

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

PHP ֆայլերի վերլուծիչների բոլոր մյուս տարբերակներն աշխատում են մոտավորապես նույն արագությամբ:

Ինչո՞ւ հենց նա առաջ անցավ իր մրցակիցներից, անկեղծ ասած, պատկերացում չունեմ։ Ես կարող եմ միայն ենթադրել, որ ֆայլը տողի մեջ կարդալու գործողությունը օգտագործելով file_get_contents ()պահանջում է ավելի քիչ ռեսուրսներ, քան օգտագործելով տողերի պատրաստի զանգված ձևավորելը ֆայլ ().

Իսկ fgets()-ի և fread()-ի նկատմամբ առավելությունը կարելի է վերագրել նրան, որ դրանք օգտագործելուց առաջ անհրաժեշտ է ֆայլը բացել fopen(-ով), ինչը ժամանակ է պահանջում։

Այո, իրականում դա նշանակություն չունի, քանի որ. Թվերն իրենք են խոսում՝ ֆունկցիայի օգտագործման շնորհիվ file_get_contents ()Դրա վրա հիմնված PHP ֆայլերի վերլուծիչն աշխատում է 5 անգամ ավելի արագ, քան մյուսները, ինչը ազդեց այն գործնականում օգտագործելու իմ որոշման վրա:

Ֆայլի վերլուծություն PHP-ում - Եզրակացություններ

Ինչպես սկզբում ասացի, իմ փորձերը անթերի չեն և չարժե հույս դնել միայն դրանց ընթացքում ստացված արդյունքների վրա, քանի որ չնայած արագությանը. file_get_contents ()Իմ իրավիճակում կան դեպքեր, երբ շատ ավելի հարմար և արդյունավետ է օգտագործել իմ տված մյուս PHP ֆայլերի վերլուծիչները։

Նաև մի մոռացեք, որ PHP-ն ինքնին սինխրոն ծրագրավորման լեզու է, այսինքն. սերվերի բոլոր գործողությունները կատարվում են հաջորդաբար, առանց դրանց զուգահեռ կատարման կազմաձևման հնարավորության, ներառյալ սերվերի պրոցեսորի տարբեր միջուկներում:

Հետևաբար, PHP կոդով գրված գործողությունների կատարման ժամանակի վրա կարող են ազդել մի շարք գործոններ, որոնցից հիմնականը PHP հավելվածի գործարկման պահին հիմնական բեռնվածությունն է:

Ես սա հատկապես զգացի փորձերի ժամանակ, երբ նույն PHP ֆայլերի վերլուծիչն աշխատում էր 9, հետո 12, և նորից 9 վայրկյան երեք անընդմեջ կրկնությունների վրա՝ երկրորդ դեպքի ժամանակ Windows Explorer-ի սովորական գործարկման պատճառով, ինչը, իհարկե, , նույնպես պահանջում է սերվերի ռեսուրսներ:

Հաշվի առնելով այս առանձնահատկությունները, ես փորձեր եմ անցկացրել գրեթե միաժամանակ, մեկը մյուսի հետևից, նույն գործող ծրագրերով, որպեսզի չցրվեն սերվերի ապարատային ռեսուրսները:

Ուստի ապագայում PHP կոնստրուկտներով նմանատիպ փորձեր կատարելիս վարվեք նույն կերպ, քանի որ. սա, փաստորեն, փորձերը հավասար պայմանների հասցնելու միակ միջոցն է։

Եթե ​​դուք աշխատում եք սերվերի կողմի ասինխրոն լեզուներով (C#, Java) կամ տեխնոլոգիաներով (օրինակ, Node.js), ապա, հնարավորության դեպքում, ստեղծեք առանձին թեմա փորձերի համար, որը կաշխատի հատուկ պրոցեսորի միջուկի վրա:

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

Ամփոփելով՝ ուզում եմ ասել, որ հոդվածում տրված կոդերի բեկորները կարող են օգտագործվել ոչ միայն PHP-ում տեքստային ֆայլերը վերլուծելու համար, այլև կատարելապես հարմար են այլ ձևաչափերի, օրինակ՝ CSV ֆայլերի վերլուծության համար։

Գրեք ձեր կարծիքը, ինչպես դրական, այնպես էլ բացասական, հոդվածի տակ գտնվող մեկնաբանություններում. Հետագա զարգացման համար ինձ անհրաժեշտ է ձեր կարծիքը 🙂

Կհանդիպենք շուտով: 🙂

P.S.Եթե ​​Ձեզ անհրաժեշտ է կայք կամ անհրաժեշտ է փոփոխություններ կատարել գոյություն ունեցողում, բայց դրա համար ժամանակ և ցանկություն չկա, ես կարող եմ առաջարկել իմ ծառայությունները:

Ավելի քան 5 տարվա փորձպրոֆեսիոնալ կայքերի մշակում. Աշխատեք հետ PHP, բաց սայլակ, WordPress, Laravel, Յիի, MySQL, PostgreSQL, JavaScript, Արձագանքել, Անկյունայինև վեբ զարգացման այլ տեխնոլոգիաներ:

Տարբեր մակարդակներում նախագծերի մշակման փորձ. վայրէջքի էջեր, կորպորատիվ կայքեր, Առցանց գնումներ, CRM, պորտալներ. Ներառյալ աջակցություն և զարգացում Բարձր բեռնվածության նախագծեր. Ուղարկեք ձեր դիմումները էլեկտրոնային փոստով [էլփոստը պաշտպանված է].

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

html պիտակների ավտոմատ հեռացում տողից

Օգտագործողի կողմից լրացված ձևեր օգտագործելիս երբեմն անհրաժեշտ է հեռացնել բոլոր ավելորդ պիտակները: Այս խնդիրը հեշտությամբ լուծվում է strip_tags() ֆունկցիայի միջոցով.

$text = strip_tags ($input, "");

Ստացեք տեքստ $start-ի և $end-ի միջև

Նման գործառույթը պետք է լինի մշակողի զինանոցում. այն վերցնում է սկզբնական տողը, սկիզբն ու վերջը և վերադարձնում է $start-ի և $end-ի միջև պարունակվող տեքստը:

GetBetween ($content,$start,$end) ֆունկցիան ($r = պայթել ($start, $content); if (isset($r)) ($r = պայթել ($end, $r); վերադարձնել $r; ) վերադարձնել «»;)

Փոխարկել URL-ը հիպերհղման

Եթե ​​դուք URL-ն տեղադրեք մեկնաբանության տեսքով WordPress բլոգում, այն ավտոմատ կերպով կվերածվի հիպերհղման: Եթե ​​ցանկանում եք իրականացնել նույն գործառույթը ձեր կայքում կամ վեբ հավելվածում, ապա կարող եք օգտագործել հետևյալ կոդը.

$url = «Ժան-Բատիստ Յունգ (http://www.webdevcat.com)»; $url = preg_replace ("#http://(+)#", " ", $url);

Տեքստի բաժանում Twitter-ի համար 140 նիշանոց զանգվածի

Գուցե դուք գիտեք դա Twitterընդունում է մինչև 140 նիշ երկարությամբ հաղորդագրություններ: Եթե ​​դուք պլանավորում եք ձեր հավելվածը փոխազդել հանրահայտ սոցիալական հաղորդագրությունների կայքի հետ, ապա այն գործառույթը, որը կրճատում է հաղորդագրությունները մինչև 140 նիշ, լավ տեղավորվում է:

Split_to_chunks($to,$text) ($total_length = (140 - strlen($to)); $text_arr = explode(" ",$text); $i=0; $message=""; foreach ($text_arr) որպես $word)( if (strlen($message[$i] . $word . " ")<= $total_length){ if ($text_arr == $word){ $message[$i] .= $word; } else { $message[$i] .= $word . " "; } } else { $i++; if ($text_arr == $word){ $message[$i] = $word; } else { $message[$i] = $word . " "; } } } return $message; }

URL-ի հեռացում տողից

Շատ մարդիկ բլոգի մեկնաբանություններում URL-ներ են թողնում` տրաֆիկ ստանալու կամ հետադարձ կապ ստանալու համար: Նման հղումները աղտոտում են բլոգը և կարող են հիասթափեցնել սեփականատիրոջը, եթե դրանք չափազանց շատ լինեն: Այսպիսով, հետևյալ գործառույթը շատ օգտակար կլինի:

$string = preg_replace("/\b(https?|ftp|ֆայլ):\/\/[ [էլփոստը պաշտպանված է]#\/%?=~_|$!:,.;]*/i", "", $string);

Փոխակերպել տողը slug-ի

Պե՞տք է գեներացնել սլագ (մշտական ​​հղման համար), որը համատեղելի է SEO-ին: Հետևյալ ֆունկցիան վերցնում է տողը որպես պարամետր և վերադարձնում է SEO-ի համատեղելի սլագ: Պարզ և արդյունավետ:

Ֆունկցիա slug($str)($str =strtolower(trim($str));$str = preg_replace("/[^a-z0-9-]/", "-", $str);$str = preg_replace ("/-+/", "-", $str); վերադարձնել $str;)

CSV ֆայլի վերլուծություն

CSV (Coma առանձնացված արժեքներ - ստորակետերով առանձնացված արժեքներ) ֆայլերը տվյալների պահպանման և փոխանցման հեշտ միջոց են, և PHP-ում նման ֆայլերի վերլուծությունը չափազանց հեշտ է: Չե՞ք հավատում։ Հետևյալ կոդը ցույց է տալիս, թե ինչպես մշակել CSV ֆայլը.

$fh = fopen ("contacts.csv", "r"); while($line = fgetcsv($fh, 1000, ",")) (echo "Contact: ($line)";)

Մեկ այլ տողի մեջ լար գտնելը

Եթե ​​տողը պարունակվում է մեկ այլ տողի մեջ, և դուք պետք է գտնեք այն, ապա խնդիրը լուծվում է պարզապես.

Ֆունկցիան պարունակում է ($str, $content, $ignorecase=true)( if ($ignorecase)( $str = strtolower($str); $content = strtolower($content); ) վերադարձնել strpos($content,$str) ? ճիշտ է կեղծ է; )

Ստուգում, թե արդյոք տողը սկսվում է կոնկրետ օրինակով

Ծրագրավորման որոշ լեզուներ, օրինակ՝ Java-ն, ունեն startWith մեթոդ/ֆունկցիա, որը թույլ է տալիս ստուգել՝ արդյոք տողը սկսվում է որոշակի օրինակով։ Ցավոք, PHP-ն չունի այդքան պարզ ներկառուցված ֆունկցիա:
Այնուամենայնիվ, մենք կարող ենք դա անել մեզ համար, և շատ պարզ.

Function String_Begins_With($needle, $haystack) ( return (substr($haystack, 0, strlen($needle))==$needle);)

Մենք հատկացնում ենքնամակ տողից

Երբևէ մտածե՞լ եք, թե ինչպես են սպամերները ստանում ձեր էլփոստի հասցեները: Ամեն ինչ պարզ է. Նրանք վերցնում են վեբ էջ (օրինակ՝ ֆորումից) և վերլուծում html կոդը՝ էլփոստի հասցեներ հանելու համար: Ստորև բերված կոդը վերցնում է տողը որպես պարամետր և տպում է իր պարունակած բոլոր նամակները: Խնդրում ենք չօգտագործել այս կոդը սպամի համար:

Extract_emails($str)( // Սովորական արտահայտություն, որը հանում է բոլոր նամակները տողից. $regexp = "/()+\@(()+\.)+((2,4))+/i"; preg_match_all ($regexp, $str, $m); վերադարձնել isset($m) ? $m : array(); ) $test_string = "Փորձարկման տող... [էլփոստը պաշտպանված է]Այլ ձևաչափերի ստուգում. [էլփոստը պաշտպանված է]; foobar Մեկ այլ ստուգում. [էլփոստը պաշտպանված է] test6example.org [էլփոստը պաշտպանված է] [էլփոստը պաշտպանված է] example.org [էլփոստը պաշտպանված է]!foo!.org foobar "; print_r(extract_emails($test_string));

Երրորդ կողմի կայքից անհրաժեշտ տեղեկատվության վերլուծության և մշակման խնդիրը վեբ ծրագրավորողի առջև կանգնած է բավականին հաճախ և տարբեր պատճառներով. այս կերպ դուք կարող եք ձեր նախագիծը լրացնել բովանդակությամբ, դինամիկ կերպով բեռնել որոշ տեղեկություններ և այլն: .

Նման դեպքերում ծրագրավորողի առաջ հարց է ծագում՝ տասնյակ գրադարաններից ո՞րն ընտրել։ Այս հոդվածում մենք փորձեցինք դիտարկել ամենատարածված տարբերակները և դրանցից ընտրել լավագույնը:

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

Թեև «սովորականները» առաջին բանն է, որ գալիս է մտքին, դուք չպետք է դրանք օգտագործեք իրական նախագծերի համար:

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

Ձեր սովորական արտահայտությունը «ավարտելու» փոխարեն կոդերի ամենափոքր փոփոխությունով, խորհուրդ ենք տալիս օգտագործել ստորև ներկայացված գործիքները. դա ավելի հեշտ է, հարմար և հուսալի:

XPath և DOM

htmlSQL

Եթե ​​դուք չեք օգտագործում PHP, կարող եք ստուգել նմանատիպ գործիքների կարճ ցուցակը ծրագրավորման այլ լեզուների համար:

Տեղադրում է HTML տողերի ընդմիջման կոդը յուրաքանչյուր նոր տողից առաջ

  • number_format - Ձևաչափում է թիվը խմբերի բաժանմամբ
  • ord - Վերադարձնում է ASCII նիշերի կոդը
  • parse_str - վերլուծում է տողը փոփոխականների
  • print - Տպում է տող
  • printf
  • quoted_printable_decode - վերծանում է տողը, որը կոդավորված է մեջբերվող տպվող մեթոդով
  • quotemeta - Փախուստ հատուկ կերպարներից
  • rtrim - Հեռացրեք բացատները տողի վերջից
  • sha1 - Վերադարձնում է տողի SHA1 հեշը
  • sha1_file - Վերադարձնում է ֆայլի SHA1 հեշը
  • similar_text - Հաշվում է երկու տողերի նմանության աստիճանը
  • soundex - Վերադարձնում է տողի soundex ստեղնը
  • sprintf
  • sscanf - Վերլուծում է տողը ըստ տրված ձևաչափի
  • strcasecmp - տառերի համեմատություն, որը թույլ չի տալիս տառատեսակներ, անվտանգ տվյալների համար երկուական ձևով
  • strcmp - Տողերի համեմատություն ապահով տվյալների համար երկուական ձևով
  • strcoll - տողերի համեմատություն՝ հաշվի առնելով ընթացիկ տեղայնությունը
  • strcspn - Վերադարձնում է հատվածի երկարությունը տողի սկզբում, որը չի համապատասխանում դիմակին
  • stripcslashes - Հեռացրեք նիշերի փախուստները, որոնք արտադրվում են addcslashes () կողմից:
  • stripos - Վերադարձնում է ենթալարի առաջին հայտնվելու դիրքը, մեծատառերի անզգայուն
  • stripslashes - Հեռացնում է նիշերի փախուստները, որոնք առաջացել են addslashes ()
  • strip_tags - Հեռացնում է HTML և PHP թեգերը տողից
  • stristr - Նման է strstr ֆունկցիային, բայց տառերի նկատմամբ զգայուն չէ
  • strlen - Վերադարձնում է տողի երկարությունը
  • strnatcasecmp - Համեմատելով մեծատառերի անզգայուն տողերը՝ օգտագործելով ալգորիթմ
  • strnatcmp - Համեմատելով տողերը՝ օգտագործելով «բնական կարգի» ալգորիթմը
  • strncasecmp
  • strncmp - Համեմատեք տողերի առաջին n նիշերը մեծատառերով, երկուական-անվտանգ
  • strpos - Գտնում է ենթալարի առաջին հայտնվելը տողի մեջ
  • strrchr
  • strrev - Հակադարձել տողը
  • strripos - Վերադարձնում է ենթալարի վերջին հայտնվելու դիրքը, մեծատառերի անզգայուն
  • strrpos - Գտնում է տողի վերջին նիշի հայտնվելը
  • strspn - Վերադարձնում է դիմակին համապատասխանող տողի սկզբում հատվածի երկարությունը
  • strstr - Գտնում է ենթալարի առաջին հայտնվելը
  • strtok – Թել բաժանել
  • strtolower - Փոխակերպել տողը փոքրատառի
  • strtoupper - Փոխակերպել տողը մեծատառի
  • strtr - Փոխակերպել տրված նիշերը
  • str_ireplace - str_replace() ֆունկցիայի մեծատառերի անզգայուն տարբերակ:
  • str_pad - Լրացրեք տողը մեկ այլ տողով տվյալ երկարությամբ
  • str_repeat - Վերադարձնում է կրկնվող տողը
  • str_replace - Որոնման տողը փոխարինում է փոխարինող տողով
  • str_rot13 - Կատարում է ROT13 փոխակերպում տողի վրա
  • str_shuffle - Խառնել նիշերը տողի մեջ
  • str_split - Տողը վերածեք զանգվածի
  • str_word_count - Վերադարձնում է տեղեկատվություն տողի բառերի մասին
  • substr - Ֆունկցիան վերադարձնում է տողի մի մասը
  • substr_count - Հաշվել ենթալարի դեպքերի քանակը տողի մեջ
  • substr_replace - Փոխարինել տողի մի մասը
  • trim - Հեռացնում է տողի սկզբից և վերջից բացատները
  • ucfirst - փոխակերպում է տողի առաջին նիշը մեծատառի
  • ucwords - փոխակերպում է յուրաքանչյուր բառի առաջին նիշը տողի մեջ մեծատառի
  • vprintf - Տպել ձևաչափված տող
  • vsprintf - Վերադարձնում է ձևաչափված տողը
  • wordwrap - տող է փաթաթում նշված թվով նիշերի միջոցով՝ օգտագործելով տողերի ընդմիջման նիշը

    • Համեմատության օպերատորների առանձնահատկությունները տողերի հետ կապված:

    $մեկ = 1; // Համար մեկ. $ զրո = 0; // Նշանակի՛ր զրո թիվը։ եթե ($one == "") echo 1; // Ակնհայտորեն հավասար չէ - չի թողարկում 1. եթե ($zero == "") echo 2; //* Ուշադրություն. Հակառակ սպասումների տպում 2! եթե ("" == $զրո) արձագանք 3; //* Եվ դա նույնպես չի օգնի, այն տպում է!.. if ("$zero" == "") echo 4; // Ճիշտ է. if (strval($zero) == "") echo 5; // Սա նույնպես ճիշտ է. այն չի տալիս 5. եթե ($zero === "") echo 6; // Ավելի լավ է, բայց վավեր չէ PHP 3-ում:

    կտրատել ()

    Chop() ֆունկցիան վերադարձնում է տող այն բանից հետո, երբ հեռացնում է հետագծերը և նոր տողերը: chop() ֆունկցիայի շարահյուսություն.

    լարային կոտլետ (լարային տող)

    Հետևյալ օրինակում chop() ֆունկցիան հեռացնում է լրացուցիչ նոր տողերը.

    $header = "Բովանդակության աղյուսակ\n\n"; $header = կոտլետ ($header); // $header = "Բովանդակության աղյուսակ"

    str_pad ()

    str_pad() ֆունկցիան տվյալ նիշերով լրացնում է տողը որոշակի երկարությամբ և վերադարձնում ձևաչափված տողը: str_pad() ֆունկցիայի շարահյուսությունը հետևյալն է.

    string str_pad (լարային տող, int padding-length [, string padding [, int padding-type]])

    Եթե ​​լրացման կամընտիր պարամետրը նշված չէ, տողը լրացվում է բացատներով: Հակառակ դեպքում, տողը լրացվում է նշված նիշերով: Լռելյայնորեն, տողը լցված է աջ կողմում; այնուամենայնիվ, դուք կարող եք padding-type պարամետրում փոխանցել հաստատունը STR_PAD_RIGHT, STR_PAD_LEFT կամ STR_PAD_BOTH, որը կփակցնի տողը տվյալ ուղղությամբ: Օրինակը ցույց է տալիս str_pad() ֆունկցիայի լցոնումը լռելյայն պարամետրերով.

    $food = «աղցան»; print str_pad ($food, 5): // Տպում է «salad» տողը Հետևյալ օրինակը օգտագործում է str_pad() ֆունկցիայի կամընտիր պարամետրերը՝ $header = «Բովանդակության աղյուսակ», տպել str_pad ($header, 5, «= +=+=" , STR_PAD_BOTH); // Զննարկիչը ցուցադրում է տող =+=+= Բովանդակության ներդիր=+=+="

    կտրել ()

    trim() ֆունկցիան հեռացնում է ցանկացած բացատ տողի երկու ծայրերից և վերադարձնում ստացված տողը: trim() ֆունկցիայի շարահյուսությունը հետևյալն է.

    լարերի կտրվածք (լարերի երկիր)

    Հեռացված բացատը ներառում է նաև \n, \r, \t, \v և \0 հատուկ նիշերը:

    ltrim ()

    Lrim() ֆունկցիան հեռացնում է բոլոր բացատները և հատուկ նիշերը տողի ձախ ծայրից և վերադարձնում ստացված տողը: ltrim() ֆունկցիայի շարահյուսությունը հետևյալն է.

    լարային ltrim (լարային տող)

    Ֆունկցիան հեռացնում է նույն հատուկ նիշերը, ինչ trim() ֆունկցիան:

    strlen ()

    Լարի երկարության որոշում

    Տողի երկարությունը նիշերով կարելի է որոշել օգտագործելով strlen() ֆունկցիան։ strlen() ֆունկցիայի շարահյուսություն.

    int strlen (լարային տող)

    Հետևյալ օրինակը ցույց է տալիս, թե ինչպես կարելի է որոշել տողի երկարությունը strlen() ֆունկցիայի միջոցով.

    $string = "բարև"; $ երկարություն = strlen ($ string); // $ երկարություն = 5

    Երկու տողերի համեմատություն

    Երկու տողերի համեմատությունը ցանկացած լեզվի ամենակարևոր լարային գործողություններից մեկն է: Չնայած այս խնդիրը կարող է լուծվել մի քանի տարբեր ձևերով, PHP-ում կան չորս տողերի համեմատման գործառույթներ.

    strcmp ()

    Strcmp() ֆունկցիան համեմատում է երկու տողերը մեծատառերի զգայուն ձևով: strcmp() ֆունկցիայի շարահյուսությունն է՝ int strcmp (string string1, string string2)

    Համեմատության ավարտից հետո strcmp()-ը վերադարձնում է երեք հնարավոր արժեքներից մեկը.

    • 0, եթե տող1 և տող2 նույնն են;
    • < 0, если строка1 меньше, чем строка2;
    • > 0, եթե տող2-ը փոքր է տող1-ից:

    $sthng1 = «կարագ»; $string2 = «կարագ»; if ((strcmp($string1. $string2)) == 0) : print "Strings are equivalent!"; endif; // եթե հրամանը վերադարձնում է TRUE

    strcasecmp ()

    strcasecmp() ֆունկցիան աշխատում է ճիշտ այնպես, ինչպես strcmp(), մեկ բացառությամբ. համեմատությունը մեծատառերի նկատմամբ զգայուն չէ: strcasecmp() ֆունկցիայի շարահյուսությունը հետևյալն է.

    int strcasecmp (string string1, string string2)

    Հետևյալ հատվածը համեմատում է երկու միանման տողեր.

    $string1 = «կարագ»; $string2 = «Կարագ»; if ((strcmp($string1, $string2)) == 0) : print "Strings are equivalent!"; endif; // եթե հրամանը վերադարձնում է TRUE

    strspn ()

    strspn() ֆունկցիան վերադարձնում է string1-ի առաջին հատվածի երկարությունը, որը պարունակում է string2-ում առկա նիշերը: strspn() ֆունկցիայի շարահյուսություն.

    int strspn (string string1, string string2)

    Հետևյալ հատվածը ցույց է տալիս, թե ինչպես է strspn() ֆունկցիան օգտագործվում գաղտնաբառը վավերացնելու համար.

    $password = "12345"; if (strspn($password, "1234567890") != strlen($password)): տպել "Գաղտնաբառը չի կարող բաղկացած լինել միայն թվերից!"; endif:

    strcspn ()

    strcspn() ֆունկցիան վերադարձնում է string1-ի առաջին հատվածի երկարությունը, որը պարունակում է string2-ում չգտնվող նիշեր: strcspn() ֆունկցիայի շարահյուսություն.

    int strcspn (string string1, string string2)

    Հետևյալ հատվածը օգտագործում է strcspn() ֆունկցիան՝ գաղտնաբառը վավերացնելու համար.

    $password = "12345"; if (strcspn($password, "1234567890") == 0) : տպել "Գաղտնաբառը չի կարող բաղկացած լինել միայն թվերից!"; endif;

    Տողերի տվյալների մշակում առանց կանոնավոր արտահայտությունների օգտագործման

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

    strtok ()

    strtok() ֆունկցիան տողը բաժանում է նշանների՝ ըստ երկրորդ պարամետրով տրված սահմանազատիչների։ strtok() ֆունկցիայի շարահյուսությունը հետևյալն է.

    լարային strtok (լարային տող, լարերի սահմանազատիչներ)

    Strtok() ֆունկցիան ունի մեկ տարօրինակություն՝ տողը ամբողջությամբ բաժանելու համար ֆունկցիան պետք է մի քանի անգամ անընդմեջ կանչել։ Հաջորդ անգամ, երբ ֆունկցիան կանչվի, այն հանում է հաջորդ նշանը տողից: Այս դեպքում տողի պարամետրը սահմանվում է միայն մեկ անգամ. ֆունկցիան հետևում է տողի ընթացիկ դիրքին, մինչև որ տողը ամբողջությամբ վերլուծվի ժետոնների կամ սահմանվի տողի նոր պարամետր: Հետևյալ օրինակը ցույց է տալիս, թե ինչպես կարելի է տողը բաժանել մի քանի սահմանազատիչների վրա.

    $info = "WJ Gi1more: [էլփոստը պաշտպանված է]| Կոլումբուս, Օհայո"; // Երկու կետ (:), խողովակ (|) և ստորակետ (.) սահմանազատիչներ $tokens = ":|,"; $tokenized = strtok($info, $tokens); // Տպել զանգվածի տարրերը $ tokenized while ($tokenized) : echo "Element = $tokenized
    "; // Նկատի ունեցեք, որ strtok-ին հաջորդող կանչերում // առաջին արգումենտը չի փոխանցվում $tokenized = strtok($tokens); endwhile; Արդյունք. Element = WJGilmore Element = [էլփոստը պաշտպանված է] Element = Columbus Element = Օհայո

    parse_str()

    Parse_str() ֆունկցիան քաղում է զույգեր տողի մեջ և վերագրում փոփոխականների արժեքները ընթացիկ տիրույթում: parse_str() ֆունկցիայի շարահյուսություն.

    void parse_str (լարային տող)

    Parse_str() ֆունկցիան հատկապես օգտակար է HTML ձևի տվյալներ կամ այլ հարուստ տեղեկատվություն պարունակող URL-ների վերլուծության ժամանակ: Հետևյալ օրինակը վերլուծում է URL-ով փոխանցված տեղեկատվությունը: Տողը էջերի միջև տվյալներ փոխանցելու ստանդարտ միջոց է՝ կամ կազմված հիպերհղման մեջ կամ մուտքագրված HTML ձևի մեջ.

    $url = "fname=wj&lname=gilmore&zip=43210"; parse_str ($url); // Parse_str() գործարկումից հետո հասանելի են հետևյալ փոփոխականները. // $fname = "wj": // $lname = "gilmore"; // $zip = "43210"

    Քանի որ այս ֆունկցիան նախատեսված է URL-ների հետ աշխատելու համար, այն անտեսում է նիշը (&):

    պայթել ()

    explode() ֆունկցիան տողը բաժանում է տարրերի և վերադարձնում այդ տարրերը որպես զանգված: Explode() ֆունկցիայի շարահյուսություն.

    զանգվածի պայթյուն (լարերի սահմանազատող, լարային տող[, int շեմ])

    Տարանջատումը տեղի է ունենում սահմանազատողի յուրաքանչյուր օրինակի համար, և ստացված հատվածների թիվը կարող է սահմանափակվել կամընտիր շեմային պարամետրով:

    Explode() ֆունկցիայի հետ տողի բաժանումը ցուցադրվում է հետևյալ օրինակում.

    $info = "wilson | բեյսբոլ | հնդկացիներ"; $user = պայթել ("|", $info); // $user = "wilson"; // $user = «բեյսբոլ»; // $user = «Հնդկացիներ»;

    explode() ֆունկցիան գրեթե նույնական է վերը նկարագրված POSIX կանոնավոր արտահայտության split() ֆունկցիային: Հիմնական տարբերությունն այն է, որ կանոնավոր արտահայտությունները որպես պարամետրեր փոխանցելը թույլատրվում է միայն split() կանչելիս:

    պայթել ()

    Եթե ​​explode() ֆունկցիան տողը բաժանում է զանգվածի տարրերի, ապա դրա նմանակը` implode() ֆունկցիան, միացնում է զանգվածը տողի մեջ: Implode() ֆունկցիայի շարահյուսությունը հետևյալն է.

    լարային պայթել (լարերի սահմանազատող, զանգվածի բեկորներ)

    Զանգվածից տողի ձևավորումը ցուցադրվում է հետևյալ օրինակում.

    $ohio_cities = զանգված ("Columbus", "Youngstown", "Cleveland", "Cincinnati"); $city_string = implode("l", $ohio_cities); // $city_string = "Columbus | Youngstown | Cleveland | Cincinnati";

    implode()-ն ունի այլանուն՝ join() ֆունկցիան:

    strpos ()

    strpos() ֆունկցիան տողի մեջ գտնում է տրված ենթատողի առաջին օրինակը։ strpos() ֆունկցիայի շարահյուսությունը հետևյալն է.

    int strpos (լարային տող, լարային ենթատող [, int offset])

    Ընտրովի պարամետրի օֆսեթը սահմանում է այն դիրքը, որտեղից պետք է սկսվի որոնումը: Եթե ​​ենթատողը չի գտնվել, strpos()-ը վերադարձնում է FALSE (0):

    Հետևյալ օրինակը որոշում է ամսաթվի առաջին հայտնվելու դիրքը log ֆայլում.

    $log = " 206.169.23.11:/www/:2000-08-10 206.169.23.11:/www/logs/:2000-02-04 206.169.23.11:/www/img/:1999-01-31"; // Որտե՞ղ է առաջին անգամ ամսագրում հայտնվում 1999թ. $pos = strpos ($log, «1999»); // $pos = 95. քանի որ «1999»-ի առաջին օրինակը // գտնվում է $log փոփոխականում պարունակվող տողի 95-րդ դիրքում:

    strrpos ()

    Strrpos() ֆունկցիան գտնում է տողում տրված նիշի վերջին հայտնվելը: strrpos() ֆունկցիայի շարահյուսություն.

    int strpos (լարային տող, char նիշ)

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

    str_replace ()

    str_replace() ֆունկցիան որոնում է տողը տվյալ ենթատողի բոլոր երևույթների համար և դրանք փոխարինում նոր ենթատողով։ str_replace() ֆունկցիայի շարահյուսությունը հետևյալն է.

    string str_replace (լարային ենթատող, տողերի փոխարինում, լարային տող)

    Substr_replace() ֆունկցիան, որը նկարագրված է ավելի ուշ այս բաժնում, թույլ է տալիս փոխարինել տողի միայն որոշակի հատված: Հետևյալը ցույց է տալիս, թե ինչպես է str_replace() ֆունկցիան օգտագործվում տողի վրա գլոբալ փոխարինում կատարելու համար։

    Եթե ​​ենթատողը երբեք չի հայտնվում տողի մեջ, սկզբնական տողը չի փոփոխվում.

    $favorite_food = «Իմ սիրելի ուտելիքներն են պաղպաղակը և հավի թևերը»; $favorite_food = str_replace("chicken_wings", "pizza", $favohte_food); // $favorite_food = «Իմ սիրելի ուտելիքներն են պաղպաղակն ու պիցցան»

    strstr()

    strstr() ֆունկցիան վերադարձնում է տողի այն հատվածը, որը սկսվում է տվյալ ենթատողի առաջին անգամից: strstr() ֆունկցիայի շարահյուսություն.

    լարային strstr (լարային տող, լարային ենթատող)

    Հետևյալ օրինակը օգտագործում է strstr() ֆունկցիան՝ URL-ից տիրույթի անուն հանելու համար.

    $url = «http://www.apress.com»; $ տիրույթ - strstr ($ url, "."); // $domain = ".apress.com"

    substr()

    Substr() ֆունկցիան վերադարձնում է տողի այն մասը, որը սկսվում է տվյալ սկզբնական դիրքից և ունի տրված երկարություն։ Substr() ֆունկցիայի շարահյուսությունը հետևյալն է.

    string substr (լարային տող, int start[, int երկարություն])

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

    • եթե մեկնարկի պարամետրը դրական է, վերադարձված ենթատողը սկսվում է տվյալ թվով տողի դիրքից.
    • եթե մեկնարկի պարամետրը բացասական է, վերադարձված ենթատողը սկսվում է դիրքից (լարի երկարությունը - սկիզբ);
    • եթե երկարության պարամետրը դրական է, վերադարձված ենթատողը ներառում է բոլոր նիշերը՝ դիրքի սկզբից մինչև դիրքի սկիզբ+երկարություն: Եթե ​​վերջին արժեքը մեծ է տողի երկարությունից, ապա վերադարձվում են նիշերը մինչև տողի վերջը.
    • եթե երկարության պարամետրը բացասական է, վերադարձված ենթատողը ավարտվում է տողի վերջից նշված հեռավորության վրա:

    Հիշեք, որ մեկնարկի պարամետրը սահմանում է տողի առաջին նիշից օֆսեթ; Այսպիսով, վերադարձված տողը իրականում սկսվում է նիշերի համարից (սկիզբ + 1):

    Հետևյալ օրինակը ցույց է տալիս, թե ինչպես կարելի է հանել տողի մի մասը substr() ֆունկցիայով.

    $car = «1944 Ford»; Smodel = substr ($ car, 6); // Մոդել = «Ֆորդ»

    Դրական երկարության պարամետրով օրինակ.

    $car = «1944 Ford»; $ մոդել = substr ($ car, 0, 4); // $model = "1944" Բացասական երկարության օրինակ՝ $car = "1944 Ford"; $ մոդել = substr ($ car, 2, -5); // $model = "44"

    substr_count()

    Substr_count() ֆունկցիան վերադարձնում է տվյալ տողում ենթատողի առաջացման թիվը: substr_count() ֆունկցիայի շարահյուսություն. int substr_count (string string, string substring) Հետևյալ օրինակում substr_count() ֆունկցիան հաշվում է ain ենթալարի դեպքերի քանակը. $tng_twist = "Անձրևը հիմնականում ընկնում է Իսպանիայի հարթավայրերում"; $count = substr_count ($tng_twist, «ain»); // $հաշվարկ = 4

    substr_replace()

    Substr_replace() ֆունկցիան փոխարինում է տողի այն հատվածին, որը սկսվում է տվյալ դիրքից։ Եթե ​​տրված է կամընտիր պարամետրի երկարությունը, ապա նշված երկարության հատվածը փոխարինվում է. հակառակ դեպքում փոխարինվող տողի ամբողջ երկարությունը փոխարինվում է: Substr_replace() ֆունկցիայի շարահյուսություն.

    string substr_replace (լարային տող, տողերի փոխարինում, int start[, int երկարություն])

    Մեկնարկի և երկարության պարամետրերը սահմանվում են որոշակի կանոնների համաձայն.

    • եթե մեկնարկային պարամետրը դրական է, փոխարինումը սկսվում է տվյալ դիրքից.
    • եթե մեկնարկի պարամետրը բացասական է, փոխարինումը սկսվում է դիրքից (լարի երկարությունը - սկիզբ);
    • եթե երկարության պարամետրը դրական է, ապա տվյալ երկարության հատվածը փոխարինվում է.
    • եթե երկարության պարամետրը բացասական է, փոխարինումը ավարտվում է դիրքով (լարի երկարություն - երկարություն):

    Պարզ տեքստի փոխարինումը substr_replace() ֆունկցիայով ցուցադրվում է հետևյալ օրինակում.

    $favs = " "s սիրելի հղումները"; $name = "Alessia"; // «0, 0» պարամետրերը նշանակում են, որ փոխարինվող հատվածը սկսվում է // և ավարտվում տողի առաջին դիրքում: $favs - substr_replace( $favs, $name, 0, 0); տպել $favs:

    Արդյունք:

    Ալեսիայի սիրելի հղումները

    Տողերի և ֆայլերի փոխակերպում HTML ձևաչափի և հակառակը

    Տողը կամ ամբողջ ֆայլը վեբ բրաուզերում դիտելու համար հարմար ձևաչափի վերածելը (կամ հակառակը) ավելի հեշտ է, քան կարող է թվալ առաջին հայացքից: PHP-ում կան հատուկ գործառույթներ դրա համար։

    Տեքստը փոխակերպեք HTML-ի

    Պարզ տեքստի արագ փոխակերպումը վեբ բրաուզերի ձևաչափի շատ տարածված խնդիր է: Այս բաժնում նկարագրված գործառույթները կօգնեն ձեզ լուծել այն:

    nl2br ()

    nl2br() ֆունկցիան փոխարինում է բոլոր նոր տողերը (\n) իրենց համարժեք HTML կառուցվածքներով։

    nl2br() ֆունկցիայի շարահյուսություն.

    տող nl2br (լարային տող)

    Նոր տող նիշերը կարող են լինել կամ տեսանելի (այսինքն՝ բացահայտորեն ներառված տողում) կամ անտեսանելի (այսինքն՝ մուտքագրված խմբագրում): Հետևյալ օրինակը փոխակերպում է տեքստային տողը HTML ձևաչափի՝ \n նիշերը փոխարինելով տողերի ընդմիջումներով.

    // Խմբագրում ցուցադրված տեքստային տող: $text_recipe = " Խնջույքի սոուսի բաղադրատոմս. 1 բանկա շոգեխաշած լոլիկ 3 ճաշի գդալ թարմ կիտրոնի հյութ Խառնել, սերվերը սառը:"; // Փոխարկել նոր տողերը
    $htinl_recipe = nl2br($text_recipe) Երբ $html_recipe-ը հետագայում տպվի, հետևյալ HTML տեքստը կփոխանցվի դիտարկիչին՝ Party Sauce բաղադրատոմսը.
    1 տուփ շոգեխաշած լոլիկ
    3 ճաշի գդալ թարմ կիտրոնի հյութ
    Խառնել միասին, սերվերը սառը է:

    htmlentities ()

    htmlentities() ֆունկցիան փոխակերպում է նիշերը իրենց համարժեք HTML կառուցվածքներին: htmlentities ֆունկցիայի շարահյուսությունը հետևյալն է.

    տողային html-ներ (լարային տող)

    Հետևյալ օրինակը կատարում է տողի նիշերի անհրաժեշտ փոխարինումը բրաուզերում ցուցադրելու համար.

    $user_input = «Խոհարարական գիրքը, որը կոչվում է Cafe Francaise» արժե

    htmlentities() ֆունկցիան ներկայումս աշխատում է միայն ISO-8559-1 (ISO-Latin-1) կոդավորման նիշերի համար: Բացի այդ, այն չի փոխակերպում տարածությունները այնպես, ինչպես դուք կակնկալեիք:

    htmlspecialchars ()

    htmlspecialchars() ֆունկցիան փոխարինում է որոշ նիշերի, որոնք հատուկ նշանակություն ունեն HTML համատեքստում իրենց համարժեք HTML կառուցվածքներով: htmlspecialchars() ֆունկցիայի շարահյուսությունը հետևյալն է.

    string htmlspecialchars (լարային տող)

    html հատուկ chars() ֆունկցիան ներկայումս փոխակերպում է հետևյալ նիշերը՝ & փոխարկվում է &; " " փոխարկվում է "; փոխարկվում է >:

    Մասնավորապես, այս հատկությունը թույլ չի տալիս օգտվողներին մուտքագրել HTML նշումներ ինտերակտիվ վեբ հավելվածներում (օրինակ՝ էլեկտրոնային ֆորումներում): HTML նշագրման սխալները կարող են պատճառ դառնալ, որ ամբողջ էջը սխալ ներկայացվի: Այնուամենայնիվ, այս առաջադրանքն ունի ավելի արդյունավետ լուծում՝ strip_tags() ֆունկցիայի միջոցով պիտակները ամբողջությամբ հեռացնել տողից։

    Հետևյալ օրինակը ցույց է տալիս htmlspeclalchars() ֆունկցիայի պոտենցիալ վտանգավոր նիշերի հեռացումը.

    $user_input = «Ես պարզապես չեմ կարող ստանալ PHP-ի և խոհարարության այդ հրաշալի բաղադրատոմսերի մասին!"; $conv_input = htmlspecialchars ($user_input); // $conv_input = "Ես պարզապես չեմ կարող"<> PHP-ի և ավելացրեք այդ առասպելական խոհարարության բաղադրատոմսերը:

    Եթե ​​htmlspecialchars()-ն օգտագործվում է nl2br()-ի հետ միասին, ապա վերջինս պետք է կոչվի htmlspecialchars()-ի անունով: Հակառակ դեպքում, դիզայն
    nl2br()-ի կանչով գեներացվել են տեսանելի նիշերի:

    get_html_translation_table ()

    Get_html_translation_table() ֆունկցիան ապահովում է տեքստը HTML համարժեքների փոխակերպելու հարմար միջոց: Get_htrril_translation_table() ֆունկցիայի շարահյուսությունը հետևյալն է.

    string get_html_translation_table (int աղյուսակ)

    Get_html_translation_table() ֆունկցիան վերադարձնում է թարգմանության երկու աղյուսակներից մեկը (սահմանված է աղյուսակի պարամետրով), որոնք օգտագործվում են ստանդարտ htmlspecialchars() և htmlentities() ֆունկցիաներում։ Վերադարձված արժեքը կարող է օգտագործվել մեկ այլ ստանդարտ ֆունկցիայի՝ strtr() հետ համատեղ՝ տեքստը HTML կոդի փոխարկելու համար։

    Աղյուսակի պարամետրը վերցնում է երկու արժեքներից մեկը.

    • HTML_ENTITIES;
    • HTML_SPECIALCHARS:

    Հետևյալ օրինակը օգտագործում է get_html_translation_table() ֆունկցիան տեքստը HTML կոդ փոխարկելիս.

    $string = «La pasta e il piatto piu amato Իտալիայում»; $translate = get_html_translation_table (HTML_ENTITIES); տպել strtr($string, $translate); // Հատուկ նիշերը վերածվում են HTML կառուցվածքների // և ճիշտ ցուցադրվում բրաուզերում:

    Ի դեպ, array_flip() ֆունկցիան թույլ է տալիս հակառակ ուղղությամբ տեքստը վերածել HTML-ի և վերականգնել սկզբնական տեքստը։ Ենթադրենք, նախորդ օրինակում strtr() արդյունքը տպելու փոխարեն, մենք այն վերագրեցինք $translated string փոփոխականին։

    Հետևյալ օրինակում բնօրինակ տեքստը վերականգնվում է array_flip() ֆունկցիայի միջոցով.

    $translate = array_flip ($ թարգմանել); $translated_string - «La pasta é il piatto piú amato in Italia»; $original_string = strtr($translated_string, $translate); // $original_string = "La pasta e il piatto piu amato Իտալիայում";

    strtr()

    strtr() ֆունկցիան թարգմանում է տող, այսինքն՝ փոխարինում է սկզբնաղբյուր տողի բոլոր նիշերը նպատակակետ տողի համապատասխան նիշերով։ strtr() ֆունկցիայի շարահյուսություն.

    լարային strtr (լարային տող, լարային աղբյուր, լարային նպատակակետ)

    Եթե ​​սկզբնաղբյուրի և նպատակակետի տողերը տարբեր երկարություններ ունեն, երկար տողը կտրված է կարճ տողին համապատասխանելու համար:

    strtr()-ին երկու պարամետրով կանչելու այլընտրանքային շարահյուսություն կա. Այս դեպքում երկրորդ պարամետրը պարունակում է ասոցիատիվ զանգված, որի ստեղները համապատասխանում են փոխարինող ենթատողերին, իսկ արժեքները՝ փոխարինող ենթատողերին: Հետևյալ օրինակը փոխարինում է HTML պիտակները XML-ի նման կառուցվածքներով.

    " => "

    ", "" => "

    "); $string = "

    Այսօր PHP-ով աշխատող նորություններում

    "; տպել strtr($string, $source); // Ելքային տող" Այսօր PHP-Powered News-ում" ?>

    Փոխարկել HTML-ը պարզ տեքստի

    Երբեմն դուք պետք է փոխակերպեք HTML ֆայլը պարզ տեքստի: Ստորև նկարագրված գործառույթները կօգնեն ձեզ այս առաջադրանքում:

    strip_tags ()

    strip_tags() ֆունկցիան հեռացնում է բոլոր HTML և PHP թեգերը տողից՝ թողնելով միայն տեքստը: strip_tags() ֆունկցիայի շարահյուսությունը հետևյալն է.

    string strip_tags (string string [, string allow_tags])

    Լրացուցիչ allow_tags պարամետրը թույլ է տալիս նշել պիտակներ, որոնք պետք է անտեսվեն հեռացման գործընթացում:

    Ստորև բերված է տողից բոլոր պիտակները հեռացնելու օրինակ HTML ֆունկցիա strip_tags ():

    $user_input = «Ես պարզապես Սեր PHP և ուտելիքբաղադրատոմսեր!"; $stripped_input = strip_tags ($user_input); // $stripped_input = "Ես պարզապես սիրում եմ PHP և գուրման բաղադրատոմսեր!";

    Հետևյալ օրինակում ոչ բոլոր, այլ միայն որոշ պիտակներ են հեռացվել.

    $input = «Ես Սերդեպի ուտել!$strip_input = strip_tags($user_input, " "); // $strip_input = "Ես սիրում եմ ուտել!!";

    Տեքստից պիտակների հեռացումն իրականացվում է նաև fgetss() ֆունկցիայի միջոցով։

    get_meta_tags ()

    Չնայած get_meta_tags() ֆունկցիան ուղղակիորեն կապված չէ տեքստի փոխակերպման հետ, այն շատ է օգտակար հատկությունորը պետք է նշել. get_meta_tags() ֆունկցիայի շարահյուսություն.

    զանգված get_meta_tags (լարային ֆայլի անուն/URL [, int include_path])

    Get_meta_tags() ֆունկցիան նախատեսված է ֆայլում որոնելու համար HTML պիտակներՄԵՏԱ.

    META թեգերը պարունակում են տեղեկատվություն այն էջի մասին, որն օգտագործվում է հիմնականում որոնման համակարգերի կողմից: Այս պիտակները գտնվում են պիտակների զույգի ներսում... . META թեգերի օգտագործումը ցուցադրվում է հետևյալ հատվածում (եկեք այն անվանենք օրինակ.html, քանի որ այն կօգտագործվի Ցուցակ 8.2-ում). պիտակների անունները և դրանց բովանդակությունը ասոցիատիվ զանգվածում: Ցուցակ 8.2-ը ցույց է տալիս, թե ինչպես կիրառել այս գործառույթը example.html ֆայլի վրա: Ցուցակ 8.2. META պիտակների արդյունահանում HTML ֆայլ get_meta_tags() ֆունկցիան

    $meta_tags = get_meta_tags("example.html"): // $meta_tags փոփոխականը պարունակում է զանգված հետևյալ տեղեկատվությամբ. "description" ] = "PHP Information" // $meta_tags["author"] = "KDG";

    Հետաքրքիր մանրամասն. META թեգի տվյալները կարելի է առբերել ոչ միայն սերվերում տեղակայված ֆայլերից, այլև այլ URL-ներից:

    Վերափոխեք տողը մեծատառերի և փոքրատառերի

    PHP-ն ունի տողի գործը փոխելու չորս գործառույթ.

    strtolower ()

    strtolower() ֆունկցիան փոխակերպում է տողի բոլոր այբբենական նիշերը փոքրատառերի։ strtolower() ֆունկցիայի շարահյուսությունը հետևյալն է.

    լարային լար (լարային տող)

    Ոչ այբբենական նիշերը չեն փոփոխվում ֆունկցիայի կողմից: strtolower() ֆունկցիայի միջոցով տողը փոքրատառի վերածելը ցույց է տրված հետևյալ օրինակում.

    $sentence = "Խոհարարություն և PHP-ի ԾՐԱԳՐԱՎՈՐՈՒՄԸ իմ ԵՐԿՈՒՍ ամենասիրվածն է!"; $ նախադասություն = strtolower ($ նախադասություն); // Ֆունկցիայի կանչից հետո $sentence-ը պարունակում է տողը // «խոհարարությունն ու ծրագրավորումը php-ն իմ երկու սիրելին են»:

    strtoupper ()

    Տողերը կարող են փոխակերպվել ոչ միայն ցածր, այլև մեծատառ. Փոխակերպումն իրականացվում է strtoupper() ֆունկցիայի միջոցով, որն ունի հետևյալ շարահյուսությունը.

    լարային ստրտուպեր (լարային լար)

    Ոչ այբբենական նիշերը չեն փոփոխվում ֆունկցիայի կողմից: strtoupper() ֆունկցիայի միջոցով տողը մեծատառի վերածելը ցույց է տրված հետևյալ օրինակում.

    $sentence = "Խոհարարություն և ծրագրավորում PHP-ն իմ երկու սիրելին է!"; $նախադասություն = strtoupper ($նախադասություն); // Ֆունկցիայի կանչից հետո $sentence-ը պարունակում է տողը // «PHP-ի պատրաստումը և ծրագրավորումը իմ ԵՐԿՈՒ ՍԻՐՎԱԾՆ ԵՆ»:

    ucfirst ()

    ucfirst() ֆունկցիան մեծատառերով նշում է տողի առաջին նիշը՝ ենթադրելով, որ այն այբբենական նշան է: ucfirst() ֆունկցիայի շարահյուսություն.

    լարային ucfirst (լարային տող)

    Ոչ այբբենական նիշերը չեն փոփոխվում ֆունկցիայի կողմից: ucfirst() ֆունկցիայի միջոցով տողի առաջին նիշի փոխակերպումը ցույց է տրված հետևյալ օրինակում.

    &sentence = "Խոհարարություն և PHP-ի ծրագրավորումը իմ երկու սիրելիներն են!"; $ նախադասություն = ucfirst ($ նախադասություն); // Ֆունկցիայի կանչից հետո $sentence-ը պարունակում է տողը // «Խոհարարությունն ու ծրագրավորումը PHP-ն իմ երկու սիրելին են»:

    ucwords ()

    ucwords() ֆունկցիան մեծատառերով նշում է յուրաքանչյուր բառի առաջին տառը տողի մեջ: ucwords() ֆունկցիայի շարահյուսություն.

    լարային ucwords (լարային տող»)

    Ոչ այբբենական նիշերը չեն փոփոխվում ֆունկցիայի կողմից: «Բառը» սահմանվում է որպես տողի այլ տարրերից բացատներով առանձնացված նիշերի հաջորդականություն: Հետևյալ օրինակը ցույց է տալիս բառերի առաջին նիշերի փոխակերպումը ucwords() ֆունկցիայով.

    $sentence = "Խոհարարություն և ծրագրավորում PHP-ն իմ երկու սիրելին է!"; $ նախադասություն = ucwords ($ նախադասություն); // Ֆունկցիայի կանչից հետո $sentence-ը պարունակում է տողը // «Խոհարարություն և ծրագրավորում PHP-ն իմ սիրելի երկուսն են»:

    strchr()

    strrchr("string", "o") - Գտնում է ենթալարի վերջին հայտնվելը

    Եթե ​​ենթատողը չի գտնվել, վերադարձնում է FALSE:

    Ի տարբերություն strchr(), եթե որոնված տողը բաղկացած է մեկից ավելի նիշից, ապա օգտագործվում է միայն առաջին նիշը։

    Եթե ​​երկրորդ արգումենտը տող չէ, այն փոխանցվում է ամբողջ թվին և դիտվում է որպես նիշերի կոդ:

    // ստացեք վերջին գրացուցակը $PATH $dir = substr(strrchr($PATH, ":"), 1); // ստանալ ամեն ինչ վերջին նոր տողից հետո $text = "Տող 1\nՏող 2\nՏող 3"; $last = substr(strrchr($text, 10), 1);

    highlight_string()

    highlight_string - տողի շարահյուսական ընդգծում:

    խառը highlight_string (string str[, bool վերադարձ])

    Highlight_string() ֆունկցիան թողարկում է str-ի շարահյուսական գունավոր տարբերակը՝ օգտագործելով PHP-ի ներկառուցված շարահյուսության ընդգծման մեջ սահմանված գույները:

    Եթե ​​վերադարձի երկրորդ պարամետրը TRUE է, ապա highlight_string() կվերադարձնի ընդգծված կոդի տարբերակը որպես տող՝ այն տպելու փոխարեն։ Եթե ​​երկրորդ պարամետրը TRUE չէ, highlight_string()-ը հաջողության դեպքում կվերադարձնի TRUE, ձախողման դեպքում՝ FALSE:

    Նշում. 1. Վերադարձի պարամետրը հասանելի է PHP 4.2.0-ից: Մինչ այդ այն աշխատում էր որպես լռելյայն, այսինքն. ՍՈՒՏ.
    2. Highlight_String() ֆունկցիան տարբերում է PHP կոդը ըստ թեգերի. show_source ()- հոմանիշ highlight_file (). Լռելյայն լուսավորության գույնը փոխելու համար օգտագործեք հետևյալ PHP հրահանգները.

    Highlight.bg #FFFFFF highlight.comment #FF8000 highlight.default #0000BB highlight.html #000000 highlight.keyword #007700 highlight.string #DD0000 in .htaccess. php_flag highlight.bg #FFFFFF in PHP. .bg")=="") ...

    addslashes ()

    - Փախչում է հատուկ նիշերից տողի մեջ

    Վերադարձնում է տողը, որն ունի յուրաքանչյուր հատուկ նիշի նախածանցով (\) նախածանց, օրինակ՝ հետագայում տվյալների բազայի հարցումներում օգտագործելու համար:

    Մեկ չակերտը ("), կրկնակի մեջբերումը ("), հետին կտրվածքը (\) և NUL (NULL բայթ) դուրս են մնացել:

    $str = «Արդյո՞ք ձեր անունը O»reilly է»: // ելքեր. Ձեր անունը O\»reilly է: echo addslashes ($str);

    քերթվածներ

    - Հեռացնում է նիշերի փախուստները, որոնք արտադրվում են addslashes() կողմից: (\"-ը վերածվում է "-ի և այլն): Կրկնակի հակադարձ շեղերը (\\) փոխարկվում են միայնակ հետշեղերի (\):

    wordwrap ()

    Փաթաթում է տողը տրված թվով նիշերի միջոցով՝ օգտագործելով տողերի ընդմիջման նշան // Օգտագործելով wordwrap(). function cite ($ourText, $maxlen=60, $prefix="> ") ($st = wordwrap($ourText, $maxlen-strlen($prefix), "\n"); $st = $prefix.str_replace( "\n", "\n$prefix", $st); return $st; ) echo cite("Առաջին Մատրիցը, որը ես նախագծեցի, բնականաբար կատարյալ էր, այն արվեստի գործ էր՝ անթերի, վեհ: Հաղթանակը հավասար էր միայն իր մոնումենտալ ձախողմամբ: Նրա կործանման անխուսափելիությունն այժմ ակնհայտ է ինձ համար՝ որպես յուրաքանչյուր մարդու բնորոշ անկատարության հետևանք: Այսպիսով, ես այն վերանախագծեցի՝ հիմնվելով ձեր պատմության վրա, որպեսզի ավելի ճշգրիտ արտացոլի ձեր բնության տարբեր գրոտեսկերները: Այնուամենայնիվ, ես կրկին հիասթափված էր ձախողումից», 20);

    Առաջին Մատրիցը, որը ես մշակել եմ, բնականաբար կատարյալ էր, այն արվեստի գործ էր, անթերի, վեհ: Հաղթանակ, որին հավասար է միայն նրա մոնումենտալ ձախողումը: Նրա կործանման > անխուսափելիությունը > ակնհայտ է ինձ համար > որպես հետեւանք > անկատարության > բնորոշ յուրաքանչյուր > մարդու >. Այսպիսով, > ես > վերաձևավորեցի այն > հիմնվելով ձեր պատմության վրա, որպեսզի ավելի > ճշգրիտ արտացոլի > ձեր բնության տարբեր > գրոսկերները: > Այնուամենայնիվ, ես > կրկին > հիասթափված էի > ձախողումից:


    Կարդալ ավելին:

    Կայքերը կարելի է բաժանել ստատիկ և դինամիկ: HTML-ին և CSS-ին տիրապետելուց հետո, որոնք թույլ են տալիս գեղեցիկ այցեքարտ պատրաստել ինտերնետում, շատերը մտածում են, թե ինչպես ստեղծել դինամիկ կայք PHP-ում։ Միաժամանակ, դասավորության դիզայները պետք է հաշվի առնի, որ այժմ նա սկսում է սովորել վեբ ծրագրավորում՝ կայքի հետ աշխատելու սկզբունքները տարբեր են լինելու։ Առաջին խնդիրներից մեկը, որին բախվում է PHP-ի սկսնակը, տողերի հետ աշխատելն է, դրանք կարդալը և մշակելը:

    Հարկ է նշել, որ PHP-ն ենթադրում է մեծ թվով մեթոդներ, այնպես որ դուք պետք է սկսեք սովորել դրանք ամենապարզ մանիպուլյացիաներով, ինչպիսիք են տողի դուրսբերումը, ենթատողի գտնելը, ստացումը կամ փոխարինումը, տառերի տառերը փոխելը և տողի երկարությունը վերադարձնելը: Շատ գործառույթներ լավ չեն աշխատում կիրիլյան նիշերի հետ: Հետևաբար, պարզության համար բոլոր օրինակները գրված են անգլերենով: Կիրիլյան տողերի համար օգտագործվում են նույն ֆունկցիաները, բայց mb_ նախածանցով (օրինակ՝ mb_strpos()): Նախքան անալոգներ օգտագործելը, php.ini-ում դուք պետք է չմեկնաբանեք տողը, extension=php_mbstring.dll՝ պարզապես հեռացնելով ստորակետը:

    Տողերի ստեղծում և թողարկում

    Մենք վերլուծելու ենք տողի ելքը դեպի էկրան՝ օգտագործելով հայտնի լեզվական կառուցվածքը echo: Ծրագրավորողը կարող է միանգամից դուրս բերել տողը.

    echo «Սա նոր գիծ է»

    կամ նախ ստեղծեք փոփոխական և այնուհետև տպեք այն էկրանին.

    $str = "Սա նոր տող է";

    Եթե ​​Ձեզ անհրաժեշտ է մի քանի տող ցուցադրել մեկում, ապա նրանք դիմում են դրանց միացմանը.

    արձագանքել «Սա». «Նոր». «Գիծ»;

    $str1 = «Սա»;

    $str2 = «Նոր»;

    $str3 = "string";

    արձագանք $str1 . $str2. $str3;

    Վերջին դեպքում էկրանը կցուցադրվի ThisNewLine. Էխո զանգահարելիս կարող է անմիջապես բացատ ավելացվել.

    արձագանք $str1 . «». $str2. «». $str3;

    Այս դեպքում էկրանին կցուցադրվի՝ «Սա նոր տող է»: Կապակցումը հնարավոր է ոչ միայն ելքի ժամանակ, այլ նաև տող ստեղծելիս.

    $str1 = «Սա»;

    $str2 = «Նոր»;

    $str3 = "string";

    $string = $str1 . «». $str2. «». $str3;

    echo $string;

    Էխոն ցուցադրում է և՛ և՛ կիրիլիցա: Եթե ​​փոփոխականներից մեկը թվեր է պարունակում, ապա միացման ժամանակ այս թիվը կվերածվի համապատասխան տողի.

    $sum = $i + $i; //այժմ $sum-ը պարունակում է 4 թիվը

    արձագանք $i . «+». $i . "=" . $ գումար;

    Էկրանին կցուցադրվի՝ «2 + 2 = 4»:

    Ծառայության նշաններ

    Ենթադրենք, տողը սահմանվում է ($string = «Այսպես»): Այնուհետև կարող եք ապահով կերպով օգտագործել կառավարման հաջորդականությունները.

    • \n կատարում է տողերի սնուցում;
    • \r վերադարձնում է կառքը;
    • \" փախչում է կրկնակի մեջբերումներից.
      • echo «Տող \"կրկնակի\" չակերտներով"; //Տող «կրկնակի» չակերտներով
    • \$ փախչում է դոլար;
    • \\ փախչում է թիկունքից:

    Կան շատ այլ հաջորդականություններ, որոնք բոլորը կարելի է գտնել պաշտոնական PHP փաստաթղթերում:

    Ինչպես գտնել ենթալարի առաջին հայտնվելու դիրքը

    Եկեք ասենք, որ մենք ունենք մի պարզ տող.

    Ունենք նաև երկու տող անուններով.

    $name = «Եմելյան»;

    $anotherName = «Քեթրին»;

    Մենք պետք է իմանանք, թե արդյոք առաջին տողը պարունակում է այս երկու անունները: Դրա համար օգտագործվում է strpos($str, $search) ֆունկցիան։ Այն վերադարձնում է $search որոնված ենթատողի դիրքը, եթե այս տողը պարունակվում է սկզբնական $str-ում: Հակառակ դեպքում ֆունկցիան վերադարձնում է բուլյան արժեքը false: Օրինակ, strpos($string, $anotherName) կվերադարձնի false, իսկ strpos($string, $name) կվերադարձնի ամբողջ թիվ։ Կոդը կլինի այսպիսին (մենք կգրենք տարբերակ, երբ դիրքը ցուցադրվի էկրանին).

    $string = «Իմ անունը Եմելյան է և ես 27 տարեկան եմ»;

    $name = «Եմելյան»;

    $anotherName = «Քեթրին»;

    echo strpos ($string, $notherName); //արտահանում է կեղծ

    echo strpos ($string, $name); //տպում է ենթալարի առաջին հայտնվելու դիրքը

    Նշենք, որ տողերի համարակալումը սկսվում է զրոյից, այսինքն՝ մեր դեպքում վերջին տողում կցուցադրվի 11 թիվը (բացատները նույնպես հաշվվում են)։

    Գտնել ենթալարի և որոգայթների վերջին առաջացման դիրքը

    Եթե ​​strpos() ֆունկցիան վերադարձնում է առաջին երևույթի դիրքը, ապա դրա հակադարձ strrpos()-ը որոնում է ենթալարի վերջին հայտնվելը։

    Այստեղ համարակալման մեկնարկի հետ կապված որոշ որոգայթներ կան: Սա պետք է հաշվի առնել. PHP աշխատանքտողերի հետ կարելի է բարդացնել համեմատությունների սահմանափակումներով: Այսպիսով, ավելի լավ է չօգտագործել ժխտված համեմատության օպերատորը՝ strpos($str, $search)!=false: Ցանկացած տարբերակով PHP օրինակներՆման համարժեքով կարող է ճիշտ չաշխատել, քանի որ տողերի համարակալումը սկսվում է զրոյից, իսկ տրամաբանական մեկնաբանության մեջ 0-ը կեղծ է: Սա վերաբերում է նաև strrpos() ֆունկցիային։

    Ինչպես գտնել ենթալարի առաջացման թիվը

    Հաճախ անհրաժեշտ է գտնել ոչ թե ենթալարի առաջին կամ վերջին հայտնվելու դիրքը տողի մեջ, այլ դրանց ընդհանուր թիվը: Դրա համար օգտագործվում է substr_count() ֆունկցիան, որը մշակում է առնվազն երկու փոփոխական՝ substr_count($str, $search): Վերադարձնում է ամբողջ թիվ։ Եթե ​​անհրաժեշտ է կրճատել տողի որոնման տարածքը, ապա ֆունկցիային փոխանցվում է ևս երկու փոփոխական՝ համապատասխանաբար տողի սկիզբը և վերջը։ Այսինքն՝ ֆունկցիան այս դեպքում կոչվում է այսպես՝ substr_count($str, $search, $start, $end): Ֆունկցիան կփնտրի $search ենթատողը $start-ի և $end սկզբնական տողի $str-ի միջև: Եթե ​​տողը չի գտնվել, ապա ֆունկցիան կվերադարձնի զրո:

    Ինչպես փոխել տողի գործը PHP-ում. Օրինակներ

    Գործի փոփոխությունը հաճախ օգտագործվում է տողերը համեմատելու համար և, ասենք, օգտագործողը պետք է մուտքագրի գերագույն աստծո անունը Ծրագիրը ունի «Մեկ» տարբերակը, որի հետ կհամեմատվի օգտատիրոջ պատասխանը։ Եթե ​​մուտքագրված տեքստը չի համընկնում եղածի հետ (օրինակ՝ օգտատերը գրում է «մեկ» կամ «ՄԵԿ»), ապա ծրագիրը true-ի փոխարեն կվերադարձնի false: Դրանից խուսափելու համար օգտագործվում է դեպքի փոփոխության ֆունկցիա: Սա հաճախ օգտագործվում է, եթե PHP կայքը ունի պիտակներ. «մասնավոր» բառի հարյուրավոր տատանումների փոխարեն («Անձնական», «մասնավոր», «ԱՆՁՆԱԿԱՆ» և այլն), կա միայն մեկ փոքրատառ պիտակ:

    strtolower() ֆունկցիան մեծատառը փոխում է փոքրատառի: Ենթադրենք, կա $catName = «փափկամազ» տող։ strtolower($catName) ֆունկցիան կվերադարձնի «փափկամազ» տողը: Դուք կարող եք մեծատառի փոխել մեծատառը՝ օգտագործելով strtoupper() ֆունկցիան:

    Ինչպես գտնել PHP-ում տողի երկարությունը՝ աշխատել գործառույթների հետ

    Հաճախ դուք ցանկանում եք գտնել լարերի երկարությունը: Օրինակ, PHP-ում նման տողերի հետ աշխատելը կարող է անհրաժեշտ լինել օղակ ստեղծելու համար: Տող փնտրելու համար օգտագործվում է strlen() ֆունկցիան, որը վերադարձնում է թիվը՝ նիշերի քանակը։ Չպետք է մոռանալ, որ վերջին նիշը կունենա strlen($str)-1 թիվը, քանի որ համարակալումը սկսվում է զրոյից։

    PHP-ում ենթատողի ստացում և փոխարինում. տողերի հետ աշխատելը

    Ենթատող ստանալը կատարվում է substr() ֆունկցիայի միջոցով, որը կարող է ընդունել երկու կամ երեք արգումենտ՝ substr($str, $start, $end): Ենթադրենք, մենք ունենք տող $string = «Fluffy cat» և ուզում ենք ստանալ ենթատողը երկրորդից չորրորդ նիշից։ Քանի որ համարակալումը սկսվում է զրոյից, այս ենթատողով փոփոխականը կունենա հետևյալ տեսքը՝ $newString = substr($string, 1, 4): Եթե ​​մուտքագրենք $newString = substr($string, 1), ապա կստանանք ենթատող երկրորդ նիշից մինչև վերջինը (այսինքն՝ «luffy»)։ Այս կոդը նույնական է ամբողջական կոդըտողեր՝ օգտագործելով strlen(): substr($string, 1, strlen($string)):

    Ենթատողը փոխարինելու համար օգտագործվում է str_replace() ֆունկցիան, որն ընդունում է երեք փոփոխական՝ str_replace($subStr, $newSub, $str): Ի տարբերություն շատ ֆունկցիաների, str_replace()-ը ճիշտ է աշխատում կիրիլյան նիշերի հետ և չունի նախածանցով անալոգ։ Օրինակ:

    $str = "Այսօր սարսափելի եղանակ!";

    $newStr = str_replace ("սարսափելի", "հրաշալի", $str); //Այսօր եղանակը հրաշալի է։

    Փոխարկել տողը թվի

    Յուրաքանչյուր ոք, ով սովորում է վեբ ծրագրավորում, վաղ թե ուշ պետք է տողը թարգմանի թվի։ Դրա համար օգտագործվում են երկու նմանատիպ ֆունկցիաներ՝ intval() և floatval(), որոնցից յուրաքանչյուրն ընդունում է մեկ $string փոփոխական։ Նրանք միմյանցից տարբերվում են միայն վերադարձված տվյալների տեսակով. intval()-ը վերադարձնում է ամբողջ թիվ, իսկ floatval()-ը՝ լողացող կետի համար։

    Ե՛վ intval()-ը, և՛ floatval()-ը պահանջում են, որ տողը սկսվի թվանշաններով, որոնք կվերածվեն թվի: Եթե ​​տառերի մի շարք հետևում է թվերին, դրանք պարզապես անտեսվելու են: Այն դեպքում, երբ տողը սկսվում է տառերով, ֆունկցիայի օգտագործումը կվերադարձնի զրո: Իդեալում, տողը պետք է պարունակի միայն թվեր:

    Թիվը տողի վերածելը

    Հաճախ դուք պետք է թվերը փոխարկեք տողի: Ենթադրենք, եթե անհրաժեշտ է վերցնել կես թվ և այն քառակուսի դնել (օրինակ, ստուգեք՝ արդյոք հավասարությունը ճշմարիտ է. 88 x 88 + 33 x 33 = 8833): Այս դեպքում օգտագործվում է strval() ֆունկցիան, որը վերադարձնում է թվով տողը։ Դրանից հետո դուք կարող եք կատարել բոլոր մյուս գործողությունները նոր տողի միջոցով՝ փոխել, որոնել ենթալարի առաջացում և այլ գործառույթներ: Անհրաժեշտության դեպքում տողը կարող է ետ վերածվել թվի՝ արդեն վերը նկարագրված ձևով:

    Հոդվածում դիտարկվել է լարերի հետ կապված բոլոր ֆունկցիաների միայն մի փոքր մասը։ Որոշ չնկարագրված գործառույթներ աշխատում են սիմվոլների հետ, սակայն դրանց մեծ մասը չի ներառվել նյութում կոնկրետության պատճառով: Այս գործառույթներին ծանոթանալու համար դուք պետք է գնաք PHP-ի պաշտոնական փաստաթղթերին, որոնք ցուցադրում են արդի տեղեկատվությունը: