(PHP 4, PHP 5, PHP 7)

փող_փոխարինել- Փոխարինում է որոնման տողի բոլոր երևույթները փոխարինող տողով

Նկարագրություն

Այս ֆունկցիան վերադարձնում է տող կամ զանգված, որտեղ որոնման բոլոր դեպքերը ենթակա են փոխարինված փոխարինմամբ:

Եթե ​​Ձեզ անհրաժեշտ չեն գտնել/փոխարինելու բարդ կանոններ (օրինակ՝ կանոնավոր արտահայտություններ), այս ֆունկցիան նախընտրելի է: preg_replace ().

Պարամետրերի ցանկ

Եթե ​​որոնումը և փոխարինումը զանգվածներ են, ապա str_replace ()օգտագործում է յուրաքանչյուր արժեք համապատասխան զանգվածից թեմայի մեջ որոնելու և փոխարինելու համար: Եթե ​​փոխարինող զանգվածում ավելի քիչ տարրեր կան, քան որոնման մեջ, դատարկ տողը կօգտագործվի որպես մնացած արժեքների փոխարինող տող: Եթե ​​որոնումը զանգված է, իսկ փոխարինումը` տող, ապա այդ փոխարինող տողը կօգտագործվի որոնման զանգվածի յուրաքանչյուր տարրի համար: Հակառակ դեպքն իմաստ չունի։

Եթե ​​որոնումը կամ փոխարինումը զանգվածներ են, դրանց տարրերը կմշակվեն առաջինից մինչև վերջ:

Արժեքը, որը դուք փնտրում եք, որը նաև հայտնի է որպես ասեղ(ասեղ): Դուք կարող եք զանգված օգտագործել բազմաթիվ որոնման արժեքների համար:

Փոխարինել

Փոխարինման արժեքը կօգտագործվի որոնված որոնման արժեքները փոխարինելու համար: Դուք կարող եք օգտագործել զանգված մի քանի արժեքների համար:

Առարկա

Որոնվող և փոխարինվող տողը կամ զանգվածը, որը նաև հայտնի է որպես խոտի դեզ(խոտի դեզ):

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

Եթե ​​ընդունվի, այն կսահմանվի կատարված փոխարինումների քանակով:

Վերադարձի արժեքներ

Այս ֆունկցիան վերադարձնում է տող կամ զանգված՝ փոխարինված արժեքներով:

Օրինակներ

Օրինակ #1 Օգտագործման օրինակներ str_replace ()

// նշանակում է
$bodytag = str_replace("%body%" , "սեւ" , " " );

// հանձնարարել՝ Hll Wrld f PHP
$vowels = array("a" , "e" , "i", "o", "u", "A", "E", "I", "O", "U");
$onlyconsonants = str_replace ($vowels , "" , "Hello World of PHP" );

// հանձնարարում է. Դուք պետք է ամեն օր պիցցա, գարեջուր և պաղպաղակ ուտեք
$ արտահայտություն = «Դուք պետք է ամեն օր ուտեք մրգեր, բանջարեղեն և մանրաթելեր»:;
$healthy = array("մրգեր" , "բանջարեղեն" , "մանրաթել" );
$yummy = array("պիցցա" , "գարեջուր" , "պաղպաղակ" );

$newphrase = str_replace ($առողջ, $yummy, $phrase);

// հանձնարարել՝ 2
$str = str_replace ("ll" , "" , "լավ golly miss molly!" , $count );
echo $count ;
?>

Օրինակ #2 Պոտենցիալ հնարքների օրինակներ str_replace ()

// Փոխարինման պատվեր
$str = «Տող 1\nԳծ 2\rԳծ 3\r\nՏող 4\n»;
$order = array("\r\n" , "\n" , "\r" );
$replace = "
" ;

// Առաջին հերթին բռնակ է \r\n՝ դրանք նորից փոխարինելուց խուսափելու համար:
echo $newstr = str_replace ($order, $replace, $str);

// Արդյունքներ F, քանի որ A-ն փոխարինվում է B-ով, ապա B-ով C-ով և այլն...
// Արդյունքում E-ն կփոխարինվի F-ով, քանի որ փոխարինումը տեղի է ունենում ձախից աջ:
$search = array("A", "B", "C", "D", "E");
$replace = array("B", "C", "D", "E", "F");
$subject = "A" ;
echo str_replace ($search, $replace, $subject);

// Արդյունքներ՝ խնձոր, ընկույզ, ընկույզ (վերը նշված պատճառով)
$letters = զանգված("I" , "o" );
$fruit = զանգված("խնձոր" , "ընկույզ" );
$text = "Ես մոտ եմ" ;
$output = str_replace ($letters, $fruit, $text);
արձագանք $ելք ;
?>

Նշումներ

Մեկնաբանություն: Այս ֆունկցիան անվտանգ է տվյալների մշակման համար երկուական ձևով:

Զգուշացում

Նշում փոխարինման կարգի վերաբերյալ

Որովհետեւ str_replace ()փոխարինում է ձախից աջ, այնուհետև բազմակի փոխարինումներ օգտագործելիս այն կարող է փոխարինել նախկինում տեղադրված արժեքը մեկ այլով: Տես նաև օրինակներ այս էջում:

Մեկնաբանություն:

Այս գործառույթը մեծատառերի զգայուն է: Օգտագործեք str_place ()պատյանների նկատմամբ զգայուն փոխարինման համար:

Մեկնաբանություն: PHP 7.0.0-ում 64-բիթանոց հարթակներում չկա հասանելի տողերի երկարության սահմանափակում, 32-բիթանոց համակարգերում և ավելի վաղ: PHP տարբերակները, տողերը չեն կարող լինել 2 ԳԲ-ից ավելի (2147483647 բայթ):

Շարահյուսություն

Տողը կարելի է սահմանել չորսով տարբեր ճանապարհներ:

• միայնակ մեջբերումներ
• կրկնակի մեջբերումներ
• nowdoc շարահյուսություն (PHP 5.3.0-ից սկսած)

Միայնակ մեջբերումներ

Ամենապարզ ճանապարհըտողը սահմանելը նշանակում է այն փակել միայնակ չակերտների մեջ (նշան " ).

Տողի մեջ մեկ մեջբերում օգտագործելու համար ետ կտրեք այն ( \ ): Եթե ​​Ձեզ անհրաժեշտ է գրել հետին կտրվածքը, կրկնօրինակեք այն ( \\ ): Բոլոր մյուս հակադարձ շեղերը կմեկնաբանվեն որպես սովորական նիշեր, ինչը նշանակում է, որ եթե փորձեք օգտագործել այլ փախուստի հաջորդականություններ, ինչպիսիք են. \րկամ \n, դրանք կարտադրվեն այնպես, ինչպես կա, որևէ հատուկ վարքագծի փոխարեն:

արձագանք «Սա պարզ տող է»;

արձագանք «Կարող եք նաև տողերի մեջ մտցնել
նոր տողում այսպիսի կերպար,
սա նորմալ է»;

// Արդյունքներ. Մի օր Առնոլդն ասաց. «Ես կվերադառնամ»
արձագանք «Մի օր Առնոլդն ասաց. «Ես կվերադառնամ»;

արձագանք «Դու ջնջե՞լ ես C:\\*.*»:;

// Արդյունքներ. Դուք ջնջե՞լ եք C:\*.*:
echo «Դու ջնջե՞լ ես C:\*.*»: ;

// Արդյունք. սա չի ընդլայնվի. \n նոր տող
արձագանք "Սա չի ընդլայնվի. \n նոր տող";

// Տպում. $expand փոփոխականները նույնպես չեն ընդլայնվում $ով
արձագանք «Փոփոխականները $expand նույնպես $either չեն ընդլայնվում»;
?>

Կրկնակի մեջբերումներ

Եթե ​​տողը փակված է կրկնակի չակերտների մեջ ("), PHP-ն ճանաչում է հետևյալ հատուկ նիշերի փախուստի հաջորդականությունը.

Փախուստի հաջորդականություն

Ենթահաջորդականություն	Իմաստը
\n	նոր տող (LF կամ 0x0A (10) ASCII-ում)
\ր	փոխադրման վերադարձ (CR կամ 0x0D (13) ASCII-ում)
\ տ	հորիզոնական ներդիր (HT կամ 0x09 (9) ASCII-ում)
\v	ուղղահայաց ներդիր (VT կամ 0x0B (11) ASCII-ում) (PHP 5.2.5-ից սկսած)
\է	escape նիշ (ESC կամ 0x1B(27) ASCII-ում) (PHP 5.4.4-ից սկսած)
\ զ	էջի հոսք (FF կամ 0x0C (12) ASCII-ում) (PHP 5.2.5-ից սկսած)
\\	հետշեղ
\$	դոլարի նշան
\"	կրկնակի մեջբերում
\{1,3}	նիշերի հաջորդականություն, որը համապատասխանում է ութնյակով նիշի կանոնավոր արտահայտությանը, որը լուռ հորդում է և տեղավորվում բայթում (այսինքն՝ «\400» === «\000»)
\x(1,2)	նիշերի հաջորդականություն, որը համապատասխանում է նիշերի կանոնավոր արտահայտությանը տասնվեցական
\u(+)	Յունիկոդի նիշերի կանոնավոր արտահայտությանը համապատասխանող նիշերի հաջորդականություն, որը քարտեզագրվում է UTF-8 ներկայացման տողի վրա (ավելացվել է PHP 7.0.0-ում)

Ինչպես միայնակ չակերտների մեջ պարփակված տողի դեպքում, ցանկացած նիշից փախչելը նույնպես կտպագրի բուն փախուստի նիշը: Մինչև PHP 5.1.1-ը, հետադարձ կտրվածքը մուտք էր գործում \($var)տպագրված չէ։

Հերեդոկ

Տողերի սահմանման երրորդ եղանակը heredoc շարահյուսության օգտագործումն է. <<< . Այս հայտարարությունից հետո դուք պետք է նշեք նույնացուցիչ, ապա նոր տող: Դրանից հետո գալիս է ինքնին տողը, այնուհետև նույն նույնացուցիչը, որը փակում է ներդիրը:

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

Ուշադրություն

Շատ կարևոր է նշել, որ փակման նույնացուցիչով տողը չպետք է պարունակի այլ նիշեր, բացառությամբ ստորակետից ( ; ): Սա նշանակում է, որ նույնացուցիչը չպետք է լինի նահանջև որ ստորակետից առաջ կամ հետո չեն կարող լինել բացատներ կամ ներդիրներ: Կարևոր է նաև հասկանալ, որ փակման նույնացուցիչից առաջ առաջին նիշը պետք է լինի նոր տողի նիշ, ինչպես սահմանված է ձեր օպերացիոն համակարգի կողմից: Օրինակ, UNIX համակարգերում, ներառյալ macOS-ը, սա է \n. Փակման նույնացուցիչին նույնպես պետք է անմիջապես հաջորդի նոր տող:

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

Beispiel #1 Սխալ շարահյուսության օրինակ

դասի սնունդ (
հանրային $ բար =<<բար
EOT;
// լիցքավորումը փակման նույնացուցիչից առաջ չի թույլատրվում
}
?>

Beispiel #2 Ճիշտ շարահյուսության օրինակ

դասի սնունդ (
հանրային $ բար =<<բար
EOT;
}
?>

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

Heredoc տեքստն իրեն պահում է նույնը, ինչ կրկնակի մեջբերված տողը առանց դրանք ունենալու: Սա նշանակում է, որ դուք կարիք չունեք heredoc-ում չակերտներից խուսափելու, բայց դուք դեռ կարող եք օգտագործել վերը նշված փախուստի հաջորդականությունները: Փոփոխականները մշակվում են, բայց դուք պետք է նույնքան զգույշ լինեք հերեդոկի ներսում բարդ փոփոխականներ օգտագործելիս, որքան լարերի հետ աշխատելիս:

Beispiel #3 հերեդոկ լարերի սահմանման օրինակ

$str =<<Գծային օրինակ,
ընդգրկելով բազմաթիվ տողեր
օգտագործելով heredoc շարահյուսությունը:
EOD;

Դասարանի սնունդ
{
var $foo ;
var $bar ;

Ֆունկցիան __construct()
{
$this -> foo = "foo" ;
$this ->
}
}

$foo = newfoo();
$name = "Անուն" ;

արձագանք<<Իմ անունն է «$name»: Ես մուտքագրում եմ $foo -> foo .
Հիմա ես հանում եմ($foo -> բար [ 1 ]) .
Սա պետք է դուրս բերի մեծատառ «A»՝ \x41
EOT;
?>

Իմ անունը «Անուն» է։ Ես գրում եմ Foo. Այժմ ես թողարկում եմ Bar2-ը: Սա պետք է դուրս բերի մեծատառ «A»: A

Հնարավոր է նաև օգտագործել heredoc շարահյուսությունը՝ ֆունկցիայի փաստարկների միջոցով տվյալները փոխանցելու համար.

5.3.0 տարբերակից սկսած՝ հնարավոր է դարձել ստատիկ փոփոխականների և դասի հատկությունների/հաստատությունների սկզբնավորումը՝ օգտագործելով heredoc շարահյուսությունը.

Beispiel #5 Օգտագործելով heredoc ստատիկ փոփոխականները սկզբնավորելու համար

// Ստատիկ փոփոխականներ
functionfoo ()
{
ստատիկ $ բար =<<Այստեղ ոչինչ չկա...
պիտակ;
}

// Դասի հաստատուններ/հատկություններ
դասի սնունդ
{
const BAR =<<Հաստատուն օգտագործելու օրինակ
FOOBAR;

Հանրային $base =<<Դաշտի օգտագործման օրինակ
FOOBAR;
}
?>

PHP 5.3.0-ի դրությամբ հնարավոր է նաև շրջապատել Heredoc նույնացուցիչը կրկնակի չակերտներով.

Nowdoc

Nowdoc-ը նույնն է մեկ չակերտ տողերի համար, ինչպես heredoc-ը՝ կրկնակի չակերտների համար: Nowdoc-ը նման է հերեդոկին, բայց դրա ներսում փոխարինումներ չեն կատարվում. Այս կառուցվածքը իդեալական է PHP կոդի կամ տեքստի այլ մեծ բլոկների ներկառուցման համար՝ առանց դրանից խուսափելու: Սա մի փոքր նման է SGML կառուցվածքին: հայտարարելով տեքստի մի բլոկի մասին, որը նախատեսված չէ մշակման համար:

Nowdoc-ը նշված է նույն հաջորդականությամբ <<< , որն օգտագործվում է heredoc-ում, սակայն դրան հաջորդող նույնացուցիչը կցվում է առանձին չակերտների մեջ, օրինակ. <<<"EOT" . Բոլոր պայմանները, որոնք վերաբերում են heredoc նույնացուցիչներին, կիրառվում են նաև nowdoc-ի համար, հատկապես նրանք, որոնք վերաբերում են փակման նույնացուցիչին:

Beispiel #7 nowdoc օրինակ

արձագանք<<<"EOD"
տեքստի օրինակ,
ընդգրկելով բազմաթիվ տողեր
օգտագործելով nowdoc շարահյուսությունը: Հետ շեղերը միշտ վերաբերվում են բառացիորեն,
օրինակ, \\ և \":
EOD;

Այս օրինակի գործարկման արդյունքը.

Տեքստի օրինակ, որն ընդգրկում է բազմաթիվ տողեր, օգտագործելով nowdoc շարահյուսությունը: Հետ շեղերը միշտ վերաբերվում են բառացիորեն, ինչպես \\ և \»:

Օրինակ #8 Nowdoc տողերի մեջբերման օրինակ փոփոխականներով

/* Ավելի բարդ օրինակ փոփոխականներով: */
դասի սնունդ
{
հանրային $foo ;
հանրային $ բար ;

Ֆունկցիան __construct()
{
$this -> foo = "foo" ;
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}

$foo = newfoo();
$name = "Անուն" ;

արձագանք<<<"EOT"
Իմ անունը «$name» է։ Ես մուտքագրում եմ $foo->foo:
Հիմա ես գրում եմ ($foo->bar):
Սա չպետք է թողարկի մեծատառ «A»՝ \x41
EOT;
?>

Այս օրինակի գործարկման արդյունքը.

Իմ անունը «$name» է։ Ես մուտքագրում եմ $foo->foo: Հիմա ես գրում եմ ($foo->bar): Սա չպետք է թողարկի մեծատառ «A»՝ \x41

Օրինակ #9 Ստատիկ տվյալների օրինակ

դասի սնունդ (
հանրային $ բար =<<<"EOT"
բար
EOT;
}
?>

Մեկնաբանություն:

nowdoc աջակցությունն ավելացվել է PHP 5.3.0-ում:

Մշակման փոփոխականներ

Եթե ​​տողը նշված է կրկնակի չակերտներով կամ heredoc-ով, ապա դրա ներսում գտնվող փոփոխականները մշակվում են:

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

Բարդ շարահյուսությունը կարելի է ճանաչել արտահայտությունը շրջապատող գանգուր փակագծերով:

Պարզ շարահյուսություն

Եթե ​​թարգմանիչը հանդիպի դոլարի նշանի ( $ ), այն գրավում է որքան հնարավոր է շատ նիշ՝ ճիշտ փոփոխականի անունը ձևավորելու համար: Եթե ​​ցանկանում եք նշել անվան վերջը, փակեք փոփոխականի անունը գանգուր փակագծերի մեջ:

$juice = "խնձոր" ;

echo «Նա մի քիչ $juice juice խմեց». . PHP_EOL;

// Սխալ. «s»-ը փոփոխականի անվան վավեր նիշ է, բայց փոփոխականի անունը $juice է:
echo «Նա խմեց $ հյութերից պատրաստված հյութ »: ;

// Ճիշտ է. Փոփոխականի անվան վերջը խստորեն նշվում է փակագծերի միջոցով.
echo «Նա խմեց $( juice ) s-ից պատրաստված հյութ։ ;
?>

Այս օրինակի գործարկման արդյունքը.

Նա մի քիչ խնձորի հյութ խմեց։ Նա մի քիչ հյութ խմեց։ Նա խմեց մի քիչ խնձորից պատրաստված հյութ։

Զանգվածի տարր ( զանգված) կամ օբյեկտի սեփականություն ( օբյեկտ): Զանգվածի ինդեքսներում փակվող քառակուսի փակագիծը ( ] ) նշում է ինդեքսի սահմանման ավարտը: Նույն կանոնները կիրառվում են օբյեկտների հատկությունների նկատմամբ, ինչպես պարզ փոփոխականների համար:

Օրինակ #10 Պարզ շարահյուսության օրինակ

define("KOOLAID" , "koolaid1" );
$juices = array("խնձոր" , "նարնջագույն" , "koolaid1" => "մանուշակագույն" );

echo «Նա խմեց $juices [ 0 ] հյութ։ . PHP_EOL;
echo «Նա խմեց մի քանի $juices [ 1 ] հյութ»։ . PHP_EOL;
echo «Նա խմեց $juices [ koolaid1 ] հյութ։ . PHP_EOL;

դասի մարդիկ (
public $john = "John Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Public $smith = "Smith" ;
}

$մարդ = նոր մարդիկ();

echo " $people -> Ջոնը մի քանի $juices [ 0 ] հյութ խմեց։" . PHP_EOL;
echo " $people -> john-ը, ապա բարև ասաց $people -> jane ." . PHP_EOL;
echo " $people -> john "s կինը ողջունեց $people -> Robert." PHP_EOL ;
echo " $people -> Ռոբերտը ողջունեց երկու $people -> smiths ." ; // Չի աշխատի
?>

Այս օրինակի գործարկման արդյունքը.

Նա մի քիչ խնձորի հյութ խմեց։ Նա մի քիչ նարնջի հյութ խմեց։ Նա մի քիչ մանուշակագույն հյութ խմեց։ Ջոն Սմիթը մի քիչ խնձորի հյութ խմեց: Այնուհետև Ջոն Սմիթը բարև ասաց Ջեյն Սմիթին: Ջոն Սմիթի կինը ողջունեց Ռոբերտ Փոլսենին Ռոբերտ Փոլսենը ողջունեց երկուսին:

PHP 7.1.0-ն ավելացրել է աջակցություն բացասականթվային ինդեքսներ.

Օրինակ #11 Բացասական թվային ինդեքսներ

$string = "string" ;
արձագանք «Նիշը ինդեքսում -2 է$string [- 2] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
արձագանք «-3 դիրքում նիշը «o»-ի փոխելով ստացվում է հետևյալ տողը.$string ." , PHP_EOL ;
?>

Այս օրինակի գործարկման արդյունքը.

-2 ինդեքսով նիշը n է: -3 դիրքում նիշը «o»-ի փոխելով ստացվում է հետևյալ տողը. ուժեղ

Ավելի բարդ բանի համար օգտագործեք բարդ շարահյուսություն:

Բարդ (գանգուր) շարահյուսություն

Այն կոչվում է բարդ ոչ թե այն պատճառով, որ դժվար է հասկանալ, այլ այն պատճառով, որ թույլ է տալիս օգտագործել բարդ արտահայտություններ։

Ցանկացած սկալյար փոփոխական, զանգվածի տարր կամ առարկայի հատկություն, որը քարտեզագրված է տողի վրա, կարող է ներկայացվել տողի մեջ այս շարահյուսությամբ: Պարզապես գրեք արտահայտությունը այնպես, ինչպես կկատարեիք տողից դուրս և այնուհետև կցեք այն { Եվ } . Այնքանով, որքանով { հնարավոր չէ խուսափել, այս շարահյուսությունը կճանաչվի միայն այն ժամանակ, երբ $ հետևում է անմիջապես հետո { . Օգտագործեք {\$ Տպել {$ . Մի քանի պատկերավոր օրինակներ.

// Ցուցադրել բոլոր սխալները
error_reporting (E_ALL);

$great = "գերազանց" ;

// Չի աշխատում, ելքեր. Սա (հիանալի)
echo "Սա ( $գերազանց )" ;

// Աշխատանքներ, արդյունքներ. Սա հիանալի է
echo «Սա ($գերազանց)» ;

// Աշխատանքային
արձագանք «Այս հրապարակը լայն է($square -> width ) 00 սանտիմետր։" ;

// Աշխատում է, մեջբերված ստեղները աշխատում են միայն գանգուր փակագծերի շարահյուսությամբ
echo "Սա աշխատում է. ( $arr [ "key" ]) " ;

// Աշխատանքային
echo "Սա աշխատում է. ( $arr [ 4 ][ 3 ]) " ;

// Սա սխալ է նույն պատճառով, որ $foo-ն դրսում է
// տողեր. Այսինքն՝ դեռ կաշխատի
// բայց քանի որ PHP-ն առաջինը փնտրում է foo հաստատունը, սա կկանչի
// E_NOTICE մակարդակի սխալ (չսահմանված հաստատուն):
արձագանք «Ճիշտ չէ.( $arr [foo ][ 3 ]) " ;

// Աշխատանքային. Ներսում բազմաչափ զանգվածներ օգտագործելիս
// լարերը միշտ օգտագործում են գանգուր փակագծեր
echo "Սա աշխատում է. ( $arr [ "foo" ][ 3 ]) " ;

// Աշխատանքային.
echo «Սա աշխատում է. $arr [ «foo» ][ 3];

արձագանք «Սա նույնպես գործում է.($obj -> արժեքներ [ 3 ]-> անուն) ";

արձագանք «Սա անվանված փոփոխականի արժեքն է$name: ($( $name)) ";

արձագանք «Սա անվանմամբ փոփոխականի արժեքն է, որը վերադարձվում է getName() ֆունկցիայի կողմից.($( getName ())) ";

արձագանք «Սա փոփոխականի արժեքն է ըստ անվան վերադարձված \$object->getName():($( $object -> getName ())) " ;

// Չի աշխատում, ելքեր. Ահա թե ինչ է վերադարձնում getName()-ը. (getName())
արձագանք «Սա է վերադարձնում getName()-ը. (getName())»:;
?>

Հնարավոր է նաև մուտք գործել տողերի մեջ օբյեկտի հատկություններ՝ օգտագործելով այս շարահյուսությունը:

դասի սնունդ (
var $bar = «Ես բար եմ»: ;
}

$foo = newfoo();
$bar = "bar" ;
$baz = զանգված("foo" , "bar" , "baz" , "quux" );
echo " ( $foo -> $bar ) \n" ;
echo " ( $foo ->( $baz [ 1 ])) \n" ;
?>

Այս օրինակի գործարկման արդյունքը.

Ես բար եմ: Ես բար եմ:

Մեկնաբանություն:

Ֆունկցիաները, մեթոդի կանչերը, ստատիկ դասի փոփոխականները և դասի հաստատունները աշխատում են ներսից {$} , քանի որ PHP տարբերակը 5: Այնուամենայնիվ, նշված արժեքը կդիտարկվի որպես փոփոխականի անուն նույն համատեքստում, ինչ տողը, որով այն սահմանված է: Օգտագործելով միայնակ գանգուր բրեկետներ ( {} ) չի աշխատի ֆունկցիաների, մեթոդների, դասի հաստատունների կամ ստատիկ դասի փոփոխականների արժեքներին մուտք գործելու համար:

// Ցուցադրել բոլոր սխալները
error_reporting (E_ALL);

դասի գարեջուր (
const softdrink = "rootbeer" ;
public static $ale = "ipa" ;
}

$rootbeer = "A & W" ;
$ipa = "Alexander Keith\"s" ;

// Սա աշխատում է, ելքեր. Ես կցանկանայի A & W
echo "Ես կցանկանայի ($( beers :: softdrink )) \n" ;

// Սա նույնպես աշխատում է, ելքեր. Ես կցանկանայի Ալեքսանդր Քեյթի
echo "I'd like ($( beers :: $ale )) \n" ;
?>

Տողերի նիշերի մուտքը և այն փոխելը

Տողերի նիշերը կարող են օգտագործվել և փոփոխվել՝ նշելով դրանց օֆսեթը տողի սկզբից՝ սկսած զրոյից, տողից հետո քառակուսի փակագծերում, օրինակ՝ $str. Մտածեք այս նպատակով տողի մասին որպես նիշերի զանգված: Եթե ​​Ձեզ անհրաժեշտ է ստանալ կամ փոխարինել 1-ից ավելի նիշ, կարող եք օգտագործել գործառույթները substr()Եվ substr_replace().

Մեկնաբանություն: քանի որ PHP 7.1.0, բացասական օֆսեթ արժեքները աջակցվում են: Նրանք սահմանել են օֆսեթը տողի ծայրից։ Նախկինում բացասական փոխհատուցումները մակարդակի սխալ էին առաջացնում E_NOTICEկարդալիս (վերադարձնում է դատարկ տողը) կամ E_ԶԳՈՒՇԱՑՈՒՄգրելու վրա (տողը թողնելով անփոփոխ):

Մեկնաբանություն: Լարի նիշը կարող է հասանելի լինել նաև գանգուր փակագծերի միջոցով, օրինակ՝ $str(42):

Ուշադրություն

Տողից դուրս օֆսեթի վրա գրելու փորձը տողը կլրացնի մինչև այդ շեղումը: Ոչ ամբողջական տիպերը կվերածվեն ամբողջ թվերի: Օֆսեթի սխալ տեսակը կհանգեցնի մակարդակի սխալի E_ԶԳՈՒՇԱՑՈՒՄ. Օգտագործվում է նշանակված տողի միայն առաջին նիշը: PHP 7.1.0-ի դրությամբ դատարկ տող նշանակելը ճակատագրական սխալ կառաջացնի: Նախկինում այս դեպքում նշանակվում էր զրոյական բայթ (NULL):

Ուշադրություն

PHP-ում տողերը բայթերի ներքին զանգվածներ են: Արդյունքում, տողի մուտքը կամ փոփոխելը օֆսեթով ապահով չէ բազմաբայթով և պետք է կատարվի միայն մեկ բայթ կոդավորման տողերով, ինչպիսին է ISO-8859-1-ը:

Մեկնաբանություն: Քանի որ PHP 7.1.0, դատարկ ինդեքսի օգտագործումը հանգեցնում է ճակատագրական սխալի, նախկինում նման դեպքում տողը վերածվում էր զանգվածի առանց նախազգուշացման։

Օրինակ #12 Մի քանի տողերի օրինակ

// Ստացեք տողի առաջին նիշը
$str = «Սա թեստ է»: ;
$first = $str [0];

// Ստացեք տողի երրորդ նիշը
$երրորդ = $str [2];

// Ստացեք տողի վերջին նիշը
$str = «Սա դեռ փորձություն է»: ;
$last = $str [strlen($str)- 1];

// Փոխել տողի վերջին նիշը
$str = "Նայեք ծովին" ;
$str [strlen ($str)- 1] = "e";

?>

PHP 5.4-ի դրությամբ տողի օֆսեթը պետք է լինի կամ ամբողջ կամ թվեր պարունակող տող, հակառակ դեպքում նախազգուշացում կտրվի: Նախկինում նման տողի կողմից տրված օֆսեթ «ֆու», առանց նախազգուշացման փոխարկվել է 0 .

Օրինակ #13 Տարբերությունները PHP 5.3-ի և PHP 5.4-ի միջև

$str = "abc" ;

Var_dump ($str["1"]);
var_dump (isset ($str [ "1" ]));

Var_dump ($str[ "1.0" ]);
var_dump (isset ($str [ «1.0» ]));

Var_dump ($str["x"]);
var_dump (isset ($str [ «x» ]));

Var_dump ($str[ "1x" ]);
var_dump (isset ($str [ "1x" ]));
?>

Այս օրինակը PHP 5.3-ում գործարկելու արդյունքը հետևյալն է.

string(1) "b" bool(true) string(1) "b" bool(true) string(1) "a" bool(true) string(1) "b" bool(true)

Այս օրինակը PHP 5.4-ում գործարկելու արդյունքը հետևյալն է.

string(1) "b" bool(true) Զգուշացում. անօրինական տողերի օֆսեթ «1.0» /tmp/t.php տող 7 տողում (1) «b» bool(false) Զգուշացում. անօրինական տողերի շեղում «x» in / tmp/t.php 9 տողում (1) "a" bool(false) string(1) "b" bool(false)

Մեկնաբանություն:

Փորձելով մուտք գործել այլ տեսակի փոփոխականներ (բացառությամբ զանգվածների կամ առարկաների, որոնք իրականացնում են որոշակի ինտերֆեյսներ) կամ {} լուռ վերադարձ ԴԱՏԱՐԿ.

Մեկնաբանություն:

PHP 5.5-ն ավելացրել է շարահյուսության միջոցով շարահյուսության միջոցով նիշեր մուտք գործելու աջակցություն կամ {} .

Կան բազմաթիվ օգտակար գործառույթներ տողերի փոփոխման համար:

Հիմնական գործառույթները նկարագրված են տողային ֆունկցիաներ բաժնում, իսկ առաջադեմ որոնման և փոխարինման համար՝ Perl-ի հետ համատեղելի կանոնավոր արտահայտությունների գործառույթները։

Փոխարկել լարային

Արժեքը կարող է փոխարկվել տողի՝ օգտագործելով cast-ը (լար), կամ գործառույթներ strval (). Արտահայտություններում, որտեղ անհրաժեշտ է տող, փոխարկումը տեղի է ունենում ավտոմատ կերպով: Դա տեղի է ունենում, երբ դուք օգտագործում եք գործառույթներ արձագանքկամ տպել, կամ երբ փոփոխականի արժեքը համեմատվում է տողի հետ։ Ձեռնարկի «Տեսակներ» և «Տիպի մանիպուլյացիա» բաժինները կարդալով՝ ավելի պարզ կդառնա հետևյալը: տես նաեւ settype ().

Զանգվածները միշտ վերածվում են տողի «զանգված», այնպես որ դուք չեք կարող ցուցադրել զանգվածի բովանդակությունը ( զանգված) օգտագործելով արձագանքկամ տպելտեսնել, թե ինչ է այն պարունակում: Առանձին տարր դիտելու համար օգտագործեք նման բան echo $arr["foo"]. Ամբողջ բովանդակությունը ցուցադրելու/դիտելու վերաբերյալ խորհուրդների համար տե՛ս ստորև:

Տիպի փոփոխական փոխակերպելու համար «Օբյեկտ»ըստ տեսակի լարօգտագործվում է __toString կախարդական մեթոդը:

Իմաստը ԴԱՏԱՐԿմիշտ վերածվում է դատարկ տողի:

Ինչպես տեսնում եք վերևում, զանգվածների, օբյեկտների կամ ռեսուրսների ուղղակի լարումը չի տալիս որևէ օգտակար տեղեկատվություն իրենց արժեքների մասին, բացի դրանց տեսակներից: Վրիպազերծման համար արժեքներ դուրս բերելու ավելի նպատակահարմար միջոց է գործառույթների օգտագործումը print_r ()Եվ var_dump ().

PHP-ի արժեքների մեծ մասը կարող է փոխարկվել տողի՝ մշտական ​​պահպանման համար: Այս մեթոդը կոչվում է սերիականացում և կարող է իրականացվել ֆունկցիայի հետ սերիականացնել ().

Տողերը թվերի վերածելը

Եթե ​​տողը ճանաչվում է որպես թվային արժեք, ապա ստացված արժեքը և տեսակը որոշվում են հետևյալ կերպ.

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

Արժեքը որոշվում է տողի սկզբնական մասով: Եթե ​​տողը սկսվում է վավեր թվային արժեքով, ապա այդ արժեքը կօգտագործվի: Հակառակ դեպքում արժեքը կլինի 0 (զրո): Վավեր թվային արժեքը մեկ կամ մի քանի թվանշան է (որը կարող է պարունակել տասնորդական կետ), որին կամայականորեն նախորդում է նշան, որին հաջորդում է կամընտիր ցուցիչը: Ցուցանիշը «e» կամ «E» է, որին հաջորդում են մեկ կամ մի քանի թվանշաններ:

$foo = 1 + «10.5» ; // $foo-ն բոց է (11.5)
$foo = 1 + "-1.3e3" ; // $foo-ն բոց է (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo-ն ամբողջ թիվ է (1)
$foo = 1 + "bob3" ; // $foo-ն ամբողջ թիվ է (1)
$foo = 1 + «10 Փոքր խոզեր» ; // $foo-ն ամբողջ թիվ է (11)
$foo = 4 + «10.2 Little Piggies» ; // $foo-ն բոց է (14.2)
$foo = «10.0 խոզեր» + 1; // $foo-ն բոց է (11)
$foo = «10.0 խոզեր» + 1.0; // $foo-ն բոց է (11)
?>

Տե՛ս Unix-ի փաստաթղթերի strtod(3) բաժինը՝ այս փոխակերպման վերաբերյալ լրացուցիչ տեղեկությունների համար:

Եթե ​​ցանկանում եք փորձարկել այս բաժնի օրինակներից որևէ մեկը, պատճենեք և տեղադրեք այն և հետևյալ տողը տեսնելու, թե ինչ է տեղի ունենում.

echo "\$foo== $foo ; տեսակ՝ " . gettype ($foo) . «
\n" ;
?>

Մի ակնկալեք, որ կստանաք նիշերի կոդը՝ այն վերածելով ամբողջ թվի (ինչպես արվում է, օրինակ, C-ում): Նիշերը իրենց ASCII կոդերին փոխարկելու համար և հակառակը, օգտագործեք գործառույթները or()Եվ chr().

Տողերի տիպի իրականացման մանրամասներ

7 տարի առաջ

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

$foo =<<Ա Բ Գ Դ
ՎԵՐՋ;
?>

Սա չի նշանակում.

ֆու (<<Ա Բ Գ Դ
ՎԵՐՋ;
);
// շարահյուսական սխալ, անսպասելի ";"
?>

Առանց ստորակետի, այն լավ է աշխատում.

ֆու (<<Ա Բ Գ Դ
ՎԵՐՋ
);
?>

3 տարի առաջ

Դուք կարող եք օգտագործել տողերի նման զանգված char (ինչպես C)

$a = «Տողային զանգվածի փորձարկում»;

var_dump ($a);
// Վերադարձի տողը (17) «Տողերի զանգվածի փորձարկում»

var_dump ($a);
// Վերադարձի տողը (1) «S»

// -- Զանգվածի ձուլվածքով --
var_dump ((զանգված) $a);
// Վերադարձեք զանգված (1) ( => տող (17) «Տողային զանգվածի փորձարկում»)

var_dump ((զանգված) $a);
// Վերադարձի տողը (17) «S»

Նորիհիորի

15 տարի առաջ

Դուք կարող եք օգտագործել բարդ շարահյուսությունը՝ տողի մեջ դնելու և՛ օբյեկտի հատկությունների, և՛ օբյեկտի մեթոդների արժեքը: Օրինակ...
դասի թեստ (
հանրային $մեկ = 1;
հանրային ֆունկցիա երկու()(
վերադարձ 2;
}
}
$test = new Test();
echo "foo ( $test -> one ) bar ( $test -> two ()) " ;
?>
Թողարկվի «foo 1 bar 2»:

Այնուամենայնիվ, դուք չեք կարող դա անել ձեր անվանատարածքի բոլոր արժեքների համար: Դասի հաստատունները և ստատիկ հատկությունները/մեթոդները չեն աշխատի, քանի որ բարդ շարահյուսությունը փնտրում է «$»:
դասի թեստ (
const ONE = 1;
}
echo "foo (Test::ONE) bar" ;
?>
Սա կթողարկի «foo (Test::one) բար»: Հաստատությունները և ստատիկ հատկությունները պահանջում են, որ դուք կոտրեք տողը:

3 տարի առաջ

Զգուշացեք, որ համահունչ է «Տողերի փոխակերպումը թվերի» հետ.

Եթե ​​("123abc" == 123 ) արձագանք «(intstr == int) սխալ է ստուգում որպես ճշմարիտ»:;

// Քանի որ մի կողմը թիվ է, տողը սխալ է փոխակերպվում intstr-ից int-ի, որն այնուհետև համընկնում է թեստի համարի հետ:

// Ճիշտ է բոլոր պայմանականների համար, ինչպիսիք են if և switch հայտարարությունները (հավանաբար նաև while loops):

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

// Թվում է, որ միակ ուղղումն այն է, որ 123-ը լինի տող որպես «123», այնպես որ փոխակերպում տեղի չի ունենում:

?>

6 տարի առաջ

Լարերի առաջատար զրոները (ամենաքիչ անակնկալ) չեն համարվում որպես օկտալ:
Հաշվի առեք.
$x = «0123» + 0;
$y = 0123 + 0;
echo «x-ը $x է, y-ը $y է»; //տպում է «x-ը 123 է, y-ը՝ 83»
այլ կերպ ասած:
* սկզբնական ծածկագրում թվային տառերի առաջատար զրոները մեկնաբանվում են որպես «օկտալ», ք.ֆ. strtol().
* տողերի առաջատար զրոները (օրինակ՝ օգտվողի կողմից ներկայացված տվյալները), երբ ամբողջ թվին (ուղղակի կամ բացահայտորեն) փոխանցվում են անտեսվում և համարվում են տասնորդական, ք. strtod ().

10 տարի առաջ

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

// Հաքերային հռչակագիր
function_expr ($v) (վերադարձ $v;)
$_expr = "_expr" ;

// Մեր խաղահրապարակը
define ("qwe" , «asd»);
սահմանել(«zxc», 5 );

$a= 3 ;
$b= 4 ;

ֆունկցիան գ($a, $b) (վերադարձ$a+ $b; }

// Օգտագործում
արձագանք"Նախընտրական{ $_expr(1 + 2 )} գրառում\n"; // թողարկում է «pre 3 post»
արձագանք"Նախընտրական{ $_expr(qwe)} գրառում\n"; // թողարկում է «pre asd post»
արձագանք"Նախընտրական{ $_expr(գ($a, $b)+ zxc* 2 )} գրառում\n"; // թողարկում է «pre 17 post»

// Ընդհանուր շարահյուսությունն է ($_expr(...))
?>

2 տարի առաջ

Կարծում եմ, որ օգտակար կլինի ավելացնել այս մեկնաբանությունը, որպեսզի տեղեկատվությունը գոնե հայտնվի PHP կայքի ճիշտ էջում:

Նկատի ունեցեք, որ եթե դուք մտադիր եք օգտագործել կրկնակի մեջբերված տող ասոցիատիվ բանալիով, կարող եք հանդիպել T_ENCAPSED_AND_WHITESPACE սխալի հետ: Ոմանք սա համարում են ոչ այնքան ակնհայտ սխալի հաղորդագրություններից մեկը:

Արտահայտություն, ինչպիսին է.

$ միրգ=զանգված(
«ա»=> «խնձոր»,
«բ»=> բանան,
// և այլն
);

տպել "Սա ... է$ միրգ[ «ա»]»; // T_ENCAPSED_AND_WHITESPACE
?>

անպայման կտոր-կտոր կընկնի:

Դուք կարող եք լուծել այն հետևյալ կերպ.

տպել"Սա ... է$ միրգ[ ա] " ; // հանել բանալին
տպել"Սա ... է${ մրգեր[ «ա»]} " ; // Բարդ շարահյուսություն
տպել"Սա ... է{ $ միրգ[ «ա»]} " ; // Համալիր շարահյուսական տատանումներ
?>

Ես անձնական նախապատվություն ունեմ վերջին փոփոխության համար, քանի որ այն ավելի բնական է և ավելի մոտ է նրան, թե ինչպիսին կլիներ արտահայտությունը լարից դուրս:

Պարզ չէ (համենայնդեպս ինձ համար), թե ինչու է PHP-ն սխալ մեկնաբանում արտահայտության ներսում գտնվող մեկ մեջբերումը, բայց ես պատկերացնում եմ, որ դա կապ ունի այն փաստի հետ, որ չակերտները արժեքային տողի մաս չեն. երբ տողը արդեն վերլուծվում է, չակերտները պարզապես խոչընդոտել…

2 տարի առաջ

Երկուսն էլ պետք է աշխատեն :(

դասփորձարկում{
հանրային ստատիկ$var= «ստատիկ»;
հանրային const VAR =«կոնստ»;

հանրային գործառույթ ասել Բարև Ստատիկ() {
արձագանքԲարեւ:{ $ սա:: $var} " ;
}

հանրային գործառույթ ասել HelloConst() {
արձագանքԲարեւ:{ $ սա::VAR)" ; //Վերլուծման սխալ. շարահյուսական սխալ, անսպասելի «)», սպասվում է «[»
}
}

$obj= նորփորձարկում();
$obj-> ասել Բարև Ստատիկ();
$obj-> ասել HelloConst();

3 տարի առաջ

Մի բան, որը ես զգացել եմ, որն անկասկած կօգնի ինչ-որ մեկին: . .
Իմ խմբագրում սա շարահյուսական ընդգծում է HTML-ը և $comment-ը.

$html =<<<"EOD"
$մեկնաբանություն
EOD;

Օգտագործելով սա ցույց է տալիս բոլոր նույն գույները.

$html =<<$մեկնաբանություն
EOD;

շատ ավելի հեշտ է դարձնում դրա հետ աշխատելը

11 տարի առաջ

Ձեր միտքը փրկելու համար մի կարդացեք ամսաթվերի մասին նախորդ մեկնաբանությունները;)

Երբ երկու տողերը կարող են փոխարկվել թվերի («$a» > «$b») թեստում), ապա օգտագործվում են ստացված թվերը, այլապես FULL տողերը համեմատվում են char-առ-char:

var_dump("1.22" > "01.23" ); // bool (կեղծ)
var_dump("1.22.00" > "01.23.00" ); // bool (ճշմարիտ)
var_dump("1-22-00" > "01-23-00" ); // bool (ճշմարիտ)
var_dump((բոց)"1.22.00" > (լողացող)"01.23.00" ); // bool (կեղծ)
?>

խառը 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); ?>

Աղյուսակներ:

C_id | ընկերություն | գտնվելու վայրը
1 | OOO Որոնում | Կուդիկինոյի դաշտ 15/3
2 | ՓԲԸ Էլիտա | Սլունիսվալինսկ 133/7
3 | ԲԲԸ Պիշպիշչ | Soldatodachestroyskoe 404

Վերանորոգման տեսակը (repair_types)
r_id | վերանորոգման_տեսակներ |
1 | Մուրճ + մեխեր
2 | Գեղեցկության ուղեցույց
3 | Կապիտալ վերանորոգում

Պատվերների ցանկ (ցուցակ)
l_id | Ով | Ինչ կարիք | ժամանակ | օպերատորի մեկնաբանություն
1 | 1 | 2 | %ժամանականիշ% | %operator_text%
2 | 2 | 1 | | %text%
3 | 3 | 2 | | %text%

Աղյուսակ 1-ը պարունակում է հաճախորդների ցանկ:
Աղյուսակ 2-ը պարունակում է ծառայությունների ցանկ:
Թիվ 3 աղյուսակը պարունակում է գործառնական թիմերի ընթացիկ պատվերների ցանկը: Այս աղյուսակը պարբերաբար թարմացվում է, և այն լրացնելու համար օգտագործվում է վեբ ձև: Քանի որ բավականին շատ պատվերներ են գալիս, գրառումները մուտքագրվում են աղյուսակում՝ հաճախորդի ID-ի և ծառայության տեսքով:

Փաստորեն, խնդիրն այն է, որ երրորդ աղյուսակը պետք է ցուցադրվի «պատվերի ընտրություն» վեբ ձևով, և ID-ի փոխարեն պետք է փոխարինել համապատասխան դաշտերը այլ սյունակներից։

Կոդը՝
$query = "SELECT * FROM ցուցակից";
$ արդյունք = mysql_query ($ հարցում);
while($row=mysql_fetch_array($result. // ստանալ արդյունքներ յուրաքանչյուր տողից
( արձագանք «»;// ցուցադրել տվյալները
}

ՍՏԵՂԾԵՔ «աղյուսակի_անուն» («id» int(255) NOT NULL AUTO_INCREMENT, «ցուցակ» տեքստ (80) NOT NULL, PRIMARY KEY («id»:

INSERT INTO «table_name» («ցուցակ») VALUES («bla-bla»)

լավագույն պատասխանը $ հարցում =
"
ընտրել ընկերություններ.Ընկերություն, repair_types.Repair_types, list.comment_l
ցուցակից
ներքին միանալու ընկերություններ
ցանկում.Ով = ընկերություններ.c_id
ներքին միացման վերանորոգում_տեսակներ
ցանկում."What need" = repair_types.r_id
";

Վերջերս Habré-ում PHP լեզվի քննարկումներն ավելի շատ կրճատվել են բարդ համակարգեր նախագծելու ունակությամբ, ինչը չի կարող չուրախացնել: Այնուամենայնիվ, մի տասնյակ ամենաճանաչված վեբ շրջանակների վերանայումից հետո (Zend Framework, Adept, CakePHP, CodeIgniter, LIMB, Symfony, MZZ և այլն), ես անկեղծորեն զարմացա՝ գտնելով որոշ նշանակալի թերություններ տարրական օպտիմալացման առումով:

Որպեսզի այս թեման ավելի տեխնիկապես ուղղված լինի, արդյունքները ներկայացվում են ավելի խիստ ձևով, ինչը կարող է որոշ չափով դժվարացնել այն:

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

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

Բացի փոփոխականները տողերի մեջ փոխարինելուց և ենթատողերի հետ փոփոխականները միացնելուց, PHP-ն իրականացնում է տողերի ձևավորման առնվազն ևս մեկ եղանակ՝ աշխատել sprintf ֆունկցիայի հետ։ Տրամաբանական է ենթադրել, որ այս մեթոդը զգալիորեն զիջելու է «ստանդարտներին»՝ լրացուցիչ ֆունկցիայի կանչի և ներսում տողերի վերլուծության պատճառով։

Միակ հավելումը, մինչ ձեզ կներկայացնեմ թեստային սցենարի կոդը՝ կրկնակի մեջբերված տողերի հետ աշխատելու 2 հնարավոր տարբերակ կա՝ հաշվի առնելով կոդավորման պարզ և «առաջադեմ» ոճը։ Այն փաստը, որ փոփոխականները գտնվում են տողերի հենց սկզբում, հավանաբար չարժե ուշադրություն դարձնել, դրանք միայն օրինակներ են.
$string = "$_SERVER["HTTP_HOST"]-ը Ուլյանովսկի շրջանի վարչակազմը չէ: Մենք սիրում ենք ռուսաց լեզուն և չենք սիրում նրանց, ովքեր խոսում են այն..."
Եվ
$string = "($_SERVER["HTTP_HOST"]) Ուլյանովսկի շրջանի վարչակազմը չէ: Մենք սիրում ենք ռուսաց լեզուն և չենք սիրում նրանց, ովքեր խոսում են այն..."

Թիվ մեկ թեստ.
Դե, կարծես բոլոր վերապահումները արված են՝ ժամանակն է ցույց տալ աշխատանքի արդյունքները։ Փորձարկողի սկզբնական կոդը կարելի է գտնել այստեղ:

Սքրինշոթերը ցույց են տալիս, որ իմ վարկածը չի հաստատվել։ Sprintf-ի միջոցով լարերի հետ աշխատելու մասին ենթադրությունը միակ ճիշտն էր։ Ամենաարագը կրկնակի չակերտներով աշխատող ֆունկցիաներն էին։

Իրավիճակի մասին կարճ մտորելուց հետո պարզաբանումն ինքնին եկավ. ամբողջ հարցն այն է, որ հղման տողը, որի մեջ կատարվել են փոխարինումները, չափազանց կարճ է. նման տողի միջով անցնող վերլուծիչը մանրուք է: Այնուամենայնիվ, նույնիսկ այստեղ պարզ է, որ փոփոխականի բնիկ փոխարինումը տողի մեջ առավելություն է տալիս «առաջադեմ ոճի» նկատմամբ։
Սա նաև կապակցման մոտեցման թույլ կողմն է՝ ներդրված տվյալների ծավալը գերազանցում է ենթատողերի ծավալը։ Թե որտեղից են առաջանում գերավճարները, կարելի է կարդալ արդեն նշված հաբրաթոպի մեջ:

Այնուամենայնիվ, նույնիսկ այս մտքերը հաստատման կարիք ունեին։ Դրա համար անհրաժեշտ էր երկրորդ թեստ՝ նման անկանխատեսելի (ինձ համար) վարքագծի համար նշված հնարավոր պատճառների փոփոխություններով։ Երևում է, հինգերորդ տարբերակում շատ բան է շտկվել (խոստովանում եմ, որ php-ի հինգերորդ տարբերակում ես ընդամենը 1 թեստ եմ անցկացրել՝ շրջանցել զանգվածի տարրերը)։

Թիվ երկու թեստ.
Երկրորդ վարկածն այն է, որ հղման տողի երկարացումը, ի վերջո, կավելացնի փորձարկող ֆունկցիաների տոկոսը, որոնք կապված են կրկնակի չակերտներում տողերի ձևավորման հետ՝ համեմատած թիվ 1 թեստի արդյունքների հետ: Նույն իրավիճակը, տեսականորեն, պետք է դիտարկել գործողության նկատմամբ: sprintf ֆունկցիայի մասին: Դա պայմանավորված է, առաջին հերթին, լարերի վերլուծության անհրաժեշտությամբ և դրա վրա ծախսվող ժամանակի ավելացմամբ։ Ենթատողերի միացվող չակերտների հետ կապված իրավիճակում, կարծում եմ, որ արդյունքը կլինի մոտավորապես նույնը, ինչ առաջին թեստում, ինչը կտա մի փոքր անկում quotes_3() ֆունկցիայի կատարման ժամանակի համամասնության մեջ: ամբողջ սցենարի (բայց կատարողականության բարձրացում չկա):

Եզրակացություններ, ըստ էության, միայն դրական են և հաստատող վարկածը։ Երբ հղման տողը փոքր-ինչ ավելանում է, մեծ ծանրաբեռնվածություն է առաջանում, ինչը հանգեցնում է կրկնակի չակերտների և sprintf ֆունկցիաների կատարողականի անկմանը:

Միայնակ չակերտներում տողերի մասին ենթադրությունը նույնպես ճիշտ էր՝ առաջին թեստի ժամանակի 36,75%-ի փոխարեն, երկրորդում quotes_3() ֆունկցիան վերցրեց սցենարի կատարման ժամանակի 33,76%-ը։

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

Սա, փաստորեն, բոլորն է։ Մնում է միայն ավելացնել, որ ծրագրավորման մեջ մանրուքներ չկան (սա նրանց համար է, ովքեր սիրում են ասել «խնայողություն խաղերի վրա» (գ) Ադելֆ): Իմանալով նման նրբությունները և հաշվի առնելով դրանք՝ կարող եք գրել կոդ, որը օպտիմիզացված կլինի իր բոլոր մակարդակներում;)

PS:
Թեստեր, որոնք կատարվել են Zend Studio For Eclipse 6.0.0-ի միջոցով (Վրիպազերծիչ + պրոֆիլը ներառված է):
PHP տարբերակ 5.2.5
Debian Linux OS

PPS:
Ես ուրախ կլինեմ, եթե ինչ-որ մեկը հրապարակի այս թեստերի իր արդյունքները: Կարծում եմ, սա թույլ կտա ավելի օբյեկտիվ գնահատել լարերի փոխարինման այս կամ այն ​​մեթոդը կիրառելու անհրաժեշտությունը: Նաև շնորհակալ կլինեմ ներկայացման և դիզայնի ոճի առողջ քննադատության համար: