Php mainīgo aizstāšana virknē. Izmantojot veidnes PHP

(PHP 4, PHP 5, PHP 7)

str_replace — Aizstāj visus meklēšanas virknes gadījumus ar aizstājējvirkni

Apraksts

Šī funkcija atgriež virkni vai masīvu, kurā visi meklēšanas gadījumi tēmā ir aizstāti ar aizstāšanu.

Ja jums nav nepieciešami sarežģīti meklēšanas/aizstāšanās noteikumi (piemēram, regulāras izteiksmes), šī funkcija ir ieteicama. preg_replace ().

Parametru saraksts

Ja meklēšana un aizstāšana ir masīvi, tad str_aizvietot () izmanto katru vērtību no atbilstošā masīva, lai meklētu un aizstātu tēmu. Ja aizstāšanas masīvā ir mazāk elementu nekā meklēšanā, atlikušajām vērtībām kā aizstājējvirkne tiks izmantota tukša virkne. Ja meklēšana ir masīvs un aizstāšana ir virkne, šī aizstāšanas virkne tiks izmantota katram meklēšanas masīva elementam. Pretējā gadījumā nav jēgas.

Ja meklēšana vai aizstāšana ir masīvi, to elementi tiks apstrādāti no pirmā līdz pēdējam.

Vērtība, kas jāmeklē, zināma arī kā adata(adata). Vēlamo vērtību kopai varat izmantot masīvu.

Aizvietot

Aizstāšanas vērtība tiks izmantota, lai aizstātu meklēšanas vērtību meklēšanu. Vairākām vērtībām varat izmantot masīvu.

Priekšmets

Virkne vai masīvs, kas jāmeklē un jāaizstāj, pazīstams arī kā siena kaudze(siena kaudze).

Ja priekšmets ir masīvs, katram priekšmeta elementam tiks veikta aizstāšanas meklēšana, un funkcija atgriezīs arī masīvu.

Ja tas būs apstiprināts, tas tiks iestatīts uz veikto nomaiņu skaitu.

Atgriešanās vērtības

Šī funkcija atgriež virkni vai masīvu ar aizstātām vērtībām.

Piemēri

1. piemērs Lietošanas piemēri str_aizvietot ()

// piešķir
$ bodytag = str_replace ("% body%", "melns", " " );

// piešķir: Hll Wrld f PHP
$ patskaņi = masīvs ("a", "e", "i", "o", "u", "A", "E", "I", "O", "U");
$ onlyconsonants = str_replace ($ patskaņi, "", "Hello World of PHP");

// piešķir: Katru dienu jāēd pica, alus un saldējums
$ frāze = "Jums vajadzētu ēst augļus, dārzeņus un šķiedrvielas katru dienu.";
$ veselīgs = masīvs ("augļi", "dārzeņi", "šķiedrvielas");
$ yummy = masīvs ("pica", "alus", "saldējums");

$ newphrase = str_replace ($ veselīgs, $ garšīgs, $ frāze);

// piešķir: 2
$ str = str_replace ("ll", "", "laba golly miss Molly!", $ skaits);
atbalss $ skaits;
?>

2. piemērs Iespējamo triku piemēri ar str_aizvietot ()

// Aizstāšanas pasūtījums
$ str = "1. rinda \ n 2. rinda \ r 3. rinda \ r \ n 4. rinda \ n";
$ secība = masīvs ("\ r \ n", "\ n", "\ r");
$ aizstāt = "
" ;

// Vispirms apstrādā \ r \ n, lai izvairītos no to aizstāšanas.
echo $ newstr = str_aizvietot ($ order, $ aizvietot, $ str);

// Drukā F, jo A tiek aizstāts ar B, tad B ar C un tā tālāk ...
// Rezultātā E tiks aizstāts ar F, jo aizstāšana notiek no kreisās puses uz labo.
$ meklēšana = masīvs ("A", "B", "C", "D", "E");
$ aizstāt = masīvs ("B", "C", "D", "E", "F");
$ priekšmets = "A";
echo str_replace ($ meklēt, $ aizstāt, $ priekšmets);

// Rezultāti: ābolu-riekstu valrieksts (iepriekš minētā iemesla dēļ)
$ burti = masīvs ("i", "o");
$ augļi = masīvs ("ābols", "rieksts");
$ text = "Es esmu par";
$ izvade = str_replace ($ burti, $ auglis, $ teksts);
echo $ izeja;
?>

Piezīmes (rediģēt)

komentēt: Šī funkcija ir droša datu apstrādei binārā formā.

Brīdinājums

Aizstāšanas piezīme

Jo str_aizvietot () veic aizstāšanu no kreisās puses uz labo, tad, izmantojot vairākas aizstāšanas, var aizstāt iepriekš ievietoto vērtību ar citu. Skatiet arī piemērus šajā lapā.

komentēt:
Šī funkcija ir reģistrjutīga. Izmantot str_ireplace () reģistrjutīgai nomaiņai.

komentēt: PHP 7.0.0 uz 64 bitu platformām nav sasniedzamu virkņu garuma ierobežojumu, 32 bitu sistēmās un agrākās PHP versijas, rindas nedrīkst būt lielākas par 2 GB (2147483647 baiti).

Sintakse

Virkni var norādīt ar četriem Dažādi ceļi:

atsevišķi pēdiņas
dubultpēdiņas
nowdoc sintakse (kopš PHP 5.3.0)

Atsevišķi pēdiņas

Vienkāršākais veids virknes definēšana nozīmē tās ievietošanu atsevišķās pēdiņās ( " ).

Lai virknē izmantotu vienu pēdiņu, atkāpieties no tās ar atpakaļvērsto slīpsvītru ( \ ). Ja jums ir jāraksta pati atpakaļvērstā slīpsvītra, dublējiet to ( \\ ). Visi citi atpakaļvērstās slīpsvītras lietojumi tiks interpretēti kā parastas rakstzīmes, kas nozīmē, ka, ja mēģināsit izmantot citas atsoļa secības, piemēram, \ r vai \ n, tie tiks parādīti tādi, kādi tie ir, nevis īpašas darbības.

atbalss "šī ir vienkārša virkne";

atbalss "Var ievietot arī rindās
jaunrindas varonis, piemēram, šis,
tas ir normāli";

// Rezultāti: Arnolds reiz teica: "Es atgriezīšos"
atbalss "Arnolds reiz teica: "Es atgriezīšos";

Atbalss "Vai esat noņēmis C: \\ *. *?";

// Izvadi: vai esat noņēmis C: \ *. *?
echo "Vai esat noņēmis C: \ *. *?" ;

// Izvades: Tas netiks izvērsts: \ n jauna rindiņa
atbalss "Tas netiks izvērsts: \ n jauna rindiņa";

// Izvadi: Mainīgie $ paplašinās arī $ vai nav izvērsti
atbalss "Mainīgie $ paplašināt arī nav $ paplašināt";
?>

Dubultās pēdiņas

Ja virkne ir ievietota dubultpēdiņās ("), PHP atpazīst šādas speciālo rakstzīmju atsoļa secības:

Bēgšanas secības

Secība	Nozīme
\ n	jauna rindiņa (LF vai 0x0A (10) ASCII formātā)
\ r	vagona atgriešana (CR vai 0x0D (13) ASCII)
\ t	horizontāla cilne (HT vai 0x09 (9) ASCII formātā)
\ v	vertikālā cilne (VT vai 0x0B (11) ASCII formātā) (kopš PHP 5.2.5)
\ e	atsoļa rakstzīme (ESC vai 0x1B (27) ASCII) (kopš PHP 5.4.4)
\ f	lapas plūsma (FF vai 0x0C (12) ASCII formātā) (kopš PHP 5.2.5)
\\	atpakaļvērstā slīpsvītra
\$	dolāra zīme
\"	dubultpēdiņš
\{1,3}	rakstzīmju secība, kas atbilst regulārās izteiksmes rakstzīmei oktālā, kas klusi pārplūst, lai iekļautos baitā (piemēram, "\ 400" === "\ 000")
\ x (1,2)	rakstzīmju secība, kas atbilst regulārās izteiksmes rakstzīmei heksadecimālajā apzīmējumā
\u (+)	rakstzīmju secība, kas atbilst Unikoda rakstzīmju regulārajam izteiksmei, kas tiek kartēta uz virkni UTF-8 apzīmējumā (pievienota PHP 7.0.0)

Tāpat kā virknei, kas ir ievietota atsevišķās pēdiņās, jebkuras rakstzīmes atsoļa gadījumā tiks izvadīta arī pati atsoļa rakstzīme. Pirms PHP 5.1.1, atpakaļvērstā slīpsvītra \ ($ var) netika izdrukāts.

Heredoc

Trešais veids, kā definēt virknes, ir izmantot heredoc sintaksi: <<< ... Pēc šī operatora jānorāda identifikators, pēc tam rindas plūsma. Pēc tam nāk pati rinda un pēc tam tas pats identifikators, kas aizver ieliktni.

Līnija vajadzētu sāciet ar beigu identifikatoru, t.i. tai jāatrodas rindas pirmajā kolonnā. Turklāt identifikatoram ir jāievēro tie paši nosaukšanas noteikumi, kas attiecas uz visiem citiem PHP tagiem: tajā ir jābūt tikai burtciparu rakstzīmēm un pasvītrai, un tas nedrīkst sākties ar skaitli (pasvītras ir atļautas).

Uzmanību

Ir ļoti svarīgi atzīmēt, ka rindā ar beigu identifikatoru nedrīkst būt citas rakstzīmes, izņemot semikolu ( ; ). Tas nozīmē, ka identifikators nedrīkst būt ar atkāpi un ka pirms vai pēc semikola nedrīkst būt atstarpes vai tabulēšanas zīmes. Ir arī svarīgi saprast, ka pirmajai rakstzīmei pirms beigu identifikatora ir jābūt jaunās rindiņas rakstzīmei, kā to nosaka jūsu operētājsistēma. Piemēram, UNIX sistēmās, tostarp macOS, tas ir \ n... Jaunai rindai jāsākas arī tūlīt pēc noslēguma identifikatora.

Ja šis noteikums tiek pārkāpts un noslēguma identifikators nav "tīrs", tiek uzskatīts, ka noslēguma identifikators trūkst, un PHP turpinās to meklēt. Ja šajā gadījumā pareizais slēgšanas identifikators joprojām netiek atrasts, tas izraisīs parsēšanas kļūdu ar rindas numuru skripta beigās.

1. piemērs Nepareizs sintakses piemērs

klase foo (
publisks $ bārs =<<bārs
EOT;
// atkāpe pirms noslēguma identifikatora nav atļauta
}
?>

2. piemērs. Pareizs sintakses piemērs

klase foo (
publisks $ bārs =<<bārs
EOT;
}
?>

Heredoc nevar izmantot, lai inicializētu klases laukus. Kopš PHP 5.3 šis ierobežojums attiecas tikai uz šeit dokumentiem, kas satur mainīgos.

Heredoc teksts darbojas tāpat kā dubultpēdiņu virkne bez tiem. Tas nozīmē, ka šeit dokumentā nav jāizņem pēdiņas, taču jūs joprojām varat izmantot iepriekš minētās atsoļa secības. Mainīgie tiek apstrādāti, bet, izmantojot sarežģītus mainīgos heredoc iekšienē, jums jābūt tikpat uzmanīgiem kā strādājot ar virknēm.

3. piemērs Heredoc virknes definēšanas piemērs

$ str =<<līnijas piemērs,
aptver vairākas līnijas,
izmantojot heredoc sintaksi.
EOD;

Klase foo
{
var $ foo;
var $ bar;

Funkcija __construct ()
{
$ this -> foo = "Foo";
$ šis ->
}
}

$ foo = jauns foo ();
$ nosaukums = "Vārds";

atbalss<<Mans vārds ir "$ vārds". Es rakstu $ foo -> foo .
Tagad iznesu ārā($ foo -> bārs [1]) .
Tam vajadzētu izvadīt lielos burtus "A": \ x41
EOT;
?>

Mani sauc "Imareks". Es rakstu Foo. Tagad es parādu Bar2. Tam vajadzētu izvadīt lielo burtu "A": A

Ir iespējams arī izmantot heredoc sintaksi, lai nodotu datus, izmantojot funkciju argumentus:

Sākot ar versiju 5.3.0, kļuva iespējams inicializēt statiskos mainīgos un klases rekvizītus / konstantes, izmantojot heredoc sintaksi:

5. piemērs. Heredoc izmantošana statisko mainīgo inicializācijai

// Statiskie mainīgie
funkcija foo ()
{
statiskā $ josla =<<Te nekā nav...
LABEL;
}

// Klases konstantes / īpašības
klase foo
{
const BAR =<<Konstantes izmantošanas piemērs
FOOBAR;

Publisks $ baz =<<Lauka izmantošanas piemērs
FOOBAR;
}
?>

Sākot ar PHP 5.3.0, Heredoc identifikatoru varat ievietot arī pēdiņās:

Tagaddoc

Nowdoc ir tas pats vienpēdiņu virknēm, kas heredoc ir dubultpēdiņu virknēm. Nowdoc ir kā heredoc, bet tā iekšpusē netiek veiktas nekādas aizstāšanas... Šī konstrukcija ir ideāli piemērota PHP koda vai citu lielu teksta bloku iegulšanai bez nepieciešamības aizbēgt. Šajā ziņā tas ir nedaudz līdzīgs SGML konstrukcijai. paziņojot par neapstrādājamu teksta bloku.

Nowdoc ir norādīts ar tādu pašu secību <<< , kas tiek izmantots šeit dokumentā, bet identifikators, kas tam seko, ir ievietots atsevišķās pēdiņās, piemēram, <<<"EOT" ... Visi nosacījumi, kas attiecas uz heredoc identifikatoriem, attiecas arī uz nowdoc, īpaši tie, kas saistīti ar beigu identifikatoru.

Piemērs Nr. 7 Piemērs, izmantojot nowdoc

atbalss<<<"EOD"
Teksta paraugs,
aptver vairākas līnijas,
izmantojot nowdoc sintaksi. Slīpsvītras vienmēr tiek traktētas burtiski,
piemēram, \\ un \ ".
EOD;

Šī piemēra rezultāts:

Teksta paraugs, kas aptver vairākas rindiņas, izmantojot nowdoc sintaksi. Slīpsvītras vienmēr tiek traktētas burtiski, piemēram, \\ un \ ".

Piemērs # 8 Nowdoc virknes citēšanas piemērs ar mainīgajiem

/ * Sarežģītāks piemērs ar mainīgajiem. * /
klase foo
{
publiskais $ foo;
publiskais $ bārs;

Funkcija __construct ()
{
$ this -> foo = "Foo";
$ this -> bar = masīvs ("Bar1", "Bar2", "Bar3");
}
}

$ foo = jauns foo ();
$ nosaukums = "Vārds";

atbalss<<<"EOT"
Mans vārds ir "$ vārds". Es rakstu $ foo-> foo.
Tagad es rakstu ($ foo-> bar).
Tas nedrīkst drukāt lielos burtus "A": \ x41
EOT;
?>

Šī piemēra rezultāts:

Mans vārds ir "$ vārds". Es rakstu $ foo-> foo. Tagad es rakstu ($ foo-> bar). Tas nedrīkst drukāt lielos burtus "A": \ x41

Piemērs # 9 Piemērs, izmantojot statiskus datus

klase foo (
publisks $ bārs =<<<"EOT"
bārs
EOT;
}
?>

komentēt:
PHP 5.3.0 tika pievienots Nowdoc atbalsts.

Mainīga vadāmība

Ja virkne ir norādīta dubultpēdiņās vai izmantojot heredoc, tajā esošie mainīgie tiek apstrādāti.

Ir divu veidu sintakse: vienkārša un sarežģīta. Vienkārša sintakse ir vienkāršāka un ērtāka. Tas ļauj apstrādāt mainīgo, masīva vērtību ( masīvs) vai objekta īpašības ( objektu) ar minimālu piepūli.

Sarežģītu sintaksi var identificēt pēc krokainajām iekavām, kas aptver izteiksmi.

Vienkārša sintakse

Ja tulks sastopas ar dolāra zīmi ( $ ), tiek izmantots pēc iespējas vairāk rakstzīmju, lai izveidotu pareizo mainīgā nosaukumu. Ja vēlaties precīzi definēt vārda beigas, iekļaujiet mainīgā nosaukumu krokainās iekavās.

$ sula = "ābols";

atbalss "Viņš dzēra kādu $ sulas sulu." ... PHP_EOL;

// Nepareizi. "s" ir derīga rakstzīme mainīgā nosaukumam, bet mainīgā nosaukums ir $ sula.
atbalss "Viņš dzēra sulu no $ sulām." ;

// Pareizi. Mainīgā nosaukuma beigas ir stingri norādītas, izmantojot iekavas:
atbalss "Viņš dzēra sulu no $ (sulas) s." ;
?>

Šī piemēra rezultāts:

Viņš dzēra ābolu sulu. Viņš dzēra sulu, kas pagatavota no. Viņš dzēra kādu sulu no āboliem.

Masīva elements ( masīvs) vai objekta īpašums ( objektu). Masīva indeksos beigu kvadrātiekava ( ] ) apzīmē indeksa definīcijas beigas. Uz objektu īpašībām attiecas tie paši noteikumi kā uz vienkāršiem mainīgajiem.

10. piemērs Vienkāršs sintakses piemērs

define ("KOOLAID", "koolaid1");
$ sulas = masīvs ("ābols", "apelsīns", "koolaid1" => "violeta");

echo "Viņš dzēra dažas $ sulas [0] sulas." ... PHP_EOL;
atbalss "Viņš dzēra dažas $ sulas [1] sulas." ... PHP_EOL;
echo "Viņš dzēra dažas $ sulas [koolaid1] sulas." ... PHP_EOL;

klases cilvēki (
publisks $ john = "Džons Smits";
publisks $ jane = "Džeina Smita";
publisks $ roberts = "Roberts Paulsens";

Public $ smith = "Smith";
}

$ cilvēki = jauni cilvēki ();

echo "$ cilvēki -> Džons izdzēra $ sulas [0] sulu." ... PHP_EOL;
echo "$ cilvēki -> Džons pēc tam pasveicināja $ cilvēkus -> Džeina." ... PHP_EOL;
echo "$ cilvēki -> Džona" sieva sveicināja $ cilvēkus -> robertu. ". PHP_EOL;
echo "$ cilvēki -> Roberts sveicināja divus $ cilvēkus -> kalēji." ; // Nedarbosies
?>

Šī piemēra rezultāts:

Viņš dzēra ābolu sulu. Viņš dzēra apelsīnu sulu. Viņš dzēra purpursarkano sulu. Džons Smits dzēra ābolu sulu. Pēc tam Džons Smits sveicināja Džeinu Smitu. Džona Smita sieva sveicināja Robertu Paulsenu. Roberts Paulsens sveica abus.

PHP 7.1.0 pievieno atbalstu negatīvs skaitliskie indeksi.

11. piemērs Negatīvie skaitliskie indeksi

$ string = "virkne";
atbalss "Raksturs ar indeksu -2 ir$ virkne [- 2]. ", PHP_EOL;
$ virkne [- 3] = "o";
atbalss "Mainot rakstzīmi pozīcijā -3 uz" o ", tiek iegūta šāda rinda:$ virkne. ", PHP_EOL;
?>

Šī piemēra rezultāts:

Rakstzīme ar indeksu -2 ir n. Mainot rakstzīmi pozīcijā -3 uz "o", tiek iegūta šāda rinda: spēcīga

Sarežģītākam darbam izmantojiet sarežģītu sintaksi.

Sarežģīta (cirtainā) sintakse

To sauc par sarežģītu nevis tāpēc, ka to ir grūti saprast, bet gan tāpēc, ka tas ļauj izmantot sarežģītus izteicienus.

Jebkurš skalārs mainīgais, masīva elements vai objekta rekvizīts, kas kartēts ar virkni, var tikt attēlots virknē ar šo sintaksi. Vienkārši ierakstiet izteiksmi tāpat kā ārpus rindas un pēc tam pievienojiet to { un } ... Ciktāl { nevar izvairīties, šī sintakse tiks atpazīta tikai tad, kad $ seko tūlīt pēc tam { ... Izmantot {\$ Printēt {$ ... Daži ilustratīvi piemēri:

// Rādīt visas kļūdas
kļūdu_ziņošana (E_ALL);

$ lieliski = "lieliski";

// Nedarbojas, iznāk: Tas ir (lieliski)
echo "Tas ir ($ lieliski)";

// Darbi, iznākumi: Tas ir lieliski
echo "Tas ir ($ lieliski)";

// Strādāju
atbalss “Šis laukums ir plats($ kvadrāts -> platums) 00 centimetri. ";

// Darbojas, pēdiņās esošie taustiņi darbojas tikai ar cirtainu figūriekavu sintaksi
echo "Tas darbojas: ($ arr [" taustiņš "])";

// Strādāju
echo "Tas darbojas: ($ arr [4] [3])";

// Tas ir nepareizi tā paša iemesla dēļ kā $ foo ārpus
// stīgas. Citiem vārdiem sakot, tas joprojām darbosies.
// bet tā kā PHP vispirms meklē konstanti foo, tas izsauks
// E_NOTICE līmeņa kļūda (nenodefinēta konstante).
atbalss "Tas nav pareizi:($ arr [foo] [3]) ";

// Strādāju. Izmantojot daudzdimensiju masīvus iekšēji
// stīgas vienmēr izmanto cirtaini breketes
echo "Tas darbojas: ($ arr [" foo "] [3])";

// Strādāju.
echo "Tas darbojas:". $ arr ["foo"] [3];

atbalss "Tas arī darbojas:($ obj -> vērtības [3] -> nosaukums) ";

atbalss "Šī ir mainīgā vērtība pēc nosaukuma$ nosaukums: ($ ($ nosaukums)) ";

atbalss "Šī ir mainīgā vērtība pēc nosaukuma, ko atgriež funkcija getName ():($ (getName ())) ";

atbalss "Šī ir mainīgā vērtība pēc nosaukuma, ko \ $ objekts-> getName () atgriež:($ ($ objekts -> getName ())) ";

// Nedarbojas, izvada: Tas ir tas, ko getName () atgriež: (getName ())
atbalss "Tas ir tas, ko getName () atgriež: (getName ())";
?>

Izmantojot šo sintaksi, ir iespējams piekļūt arī objektu īpašībām virknēs.

klase foo (
var $ bar = "Es esmu bārs." ;
}

$ foo = jauns foo ();
$ bar = "josla";
$ baz = masīvs ("foo", "bar", "baz", "quux");
echo "($ foo -> $ bar) \ n";
echo "($ foo -> ($ baz [1])) \ n";
?>

Šī piemēra rezultāts:

Es esmu bārs. Es esmu bārs.

komentēt:
Funkcijas, metožu izsaukumi, statiskie klases mainīgie un klases konstantes darbojas iekšēji {$} kopš PHP 5. Tomēr norādītā vērtība tiks uzskatīta par mainīgā nosaukumu tajā pašā kontekstā kā virkne, kurā tā ir definēta. Izmantojot atsevišķas cirtainas breketes ( {} ) nedarbosies, lai piekļūtu funkciju, metožu, klases konstantu vai statisko klases mainīgo vērtībām.

// Rādīt visas kļūdas
kļūdu_ziņošana (E_ALL);

klases alus (
const bezalkoholiskais dzēriens = "sakņu alus";
public static $ ale = "ipa";
}

$ rootbeer = "A & W";
$ ipa = "Aleksandrs Kīts \" s ";

// Tas darbojas, iznāk: Es vēlētos A & W
atbalss "Es gribētu ($ (alus :: bezalkoholiskais dzēriens)) \ n";

// Tas arī darbojas, iznāk: Man patiktu Aleksandrs Kīts "s
echo "Es gribētu ($ (alus :: $ ale)) \ n";
?>

Piekļuve rakstzīmei virknē un tās modificēšana

Rakstzīmes virknēs var izmantot un modificēt, definējot to nobīdi no virknes sākuma, sākot no nulles, kvadrātiekavās aiz virknes, piemēram, $ str. Šim nolūkam padomājiet par virkni kā rakstzīmju masīvu. Ja jums ir jāiegūst vai jāaizstāj vairāk nekā 1 rakstzīme, varat izmantot funkcijas substr () un substr_replace ().

komentēt: jo tiek atbalstītas PHP 7.1.0 negatīvās nobīdes vērtības. Viņi nosaka nobīdi no rindas beigām. Iepriekš negatīvās nobīdes izraisīja līmeņa kļūdu E_NOTICE lasot (atgriežot tukšu virkni) vai nu E_BRĪDINĀJUMS rakstot (rindu atstājot nemainītu).

komentēt: Uz rakstzīmi virknē var atsaukties arī, izmantojot krokainas figūriekavas, piemēram, $ str (42).

Uzmanību

Mēģinot rakstīt uz bezsaistes nobīdi, līnija tiks papildināta ar atstarpēm līdz šai nobīdei. Veidi, kas nav veseli skaitļi, tiks pārveidoti par veseliem skaitļiem. Nepareizs nobīdes veids izraisīs līmeņa kļūdu E_BRĪDINĀJUMS... Tiek izmantota tikai piešķirtās virknes pirmā rakstzīme. Sākot ar PHP 7.1.0, tukšas virknes piešķiršana izraisīs fatālu kļūdu. Iepriekš šajā gadījumā tika piešķirts NULL baits.

Uzmanību

PHP virknes ir iekšēji baitu masīvi. Līdz ar to piekļuve virknei ar nobīdi vai tās modificēšana no vairāku baitu kodēšanas viedokļa ir nedroša, un tā jāveic tikai ar virknēm viena baita kodējumos, piemēram, ISO-8859-1.

komentēt: Sākot no PHP 7.1.0, tukša indeksa izmantošana rada fatālu kļūdu, iepriekš līdzīgā gadījumā virkne bez brīdinājuma tika pārveidota par masīvu.

12. piemērs Daži virkņu piemēri

// Iegūstiet virknes pirmo rakstzīmi
$ str = "Šis ir tests." ;
$ pirmais = $ str [0];

// Iegūstiet virknes trešo rakstzīmi
$ trešais = $ str [2];

// Iegūstiet virknes pēdējo rakstzīmi
$ str = "Tas joprojām ir tests." ;
$ pēdējais = $ str [strlen ($ str) - 1];

// Mainiet rindas pēdējo rakstzīmi
$ str = "Paskaties uz jūru";
$ str [strlen ($ str) - 1] = "e";

Kopš PHP 5.4 nobīde virknē ir jānorāda vai nu kā vesels skaitlis, vai kā virkne, kas satur skaitļus, pretējā gadījumā tiks parādīts brīdinājums. Iepriekš veidlapas rindā norādītā nobīde "foo", bez brīdinājumiem pārveidots uz 0 .

13. piemērs: PHP 5.3 un PHP 5.4 atšķirības

$ 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"]));
?>

Šī piemēra izpildes rezultāts PHP 5.3:

virkne (1) "b" bool (patiesa) virkne (1) "b" bool (patiesa) virkne (1) "a" bool (patiesa) virkne (1) "b" bool (patiesa)

Šī piemēra izpildes rezultāts PHP 5.4:

virkne (1) "b" bool (true) Brīdinājums: nelegāla virknes nobīde "1.0" failā /tmp/t.php 7. rindā virknē (1) "b" bool (false) Brīdinājums: nelegāla virknes nobīde "x" mapē / tmp / t.php 9. rindā virkne (1) "a" bool (false) string (1) "b" bool (false)

komentēt:
Mēģinājums piekļūt cita veida mainīgajiem (izņemot masīvus vai objektus, kas ievieš noteiktas saskarnes), izmantojot vai {} klusi atgriezties NULL.

komentēt:
PHP 5.5 pievienoja atbalstu piekļuvei rakstzīmēm virknes literāļos, izmantojot sintaksi vai {} .

Virkņu modificēšanai ir daudz noderīgu funkciju.

Pamatfunkcijas ir aprakstītas sadaļā par virkņu funkcijām, bet izvērstai meklēšanai un aizstāšanai – ar Perl saderīgo regulāro izteiksmju funkcijas.

Pārveido par virkni

Vērtību var pārvērst virknē, izmantojot cast (virkne), vai funkcijas strval ()... Izteiksmēs, kurās nepieciešama virkne, konvertēšana notiek automātiski. Tas notiek, kad izmantojat funkcijas atbalss vai drukāt, vai ja mainīgā vērtība tiek salīdzināta ar virkni. Izlasot rokasgrāmatas sadaļas par tipiem un manipulācijām ar tipu, būs skaidrāk norādīts. Skatīt arī settype ().

Masīvi vienmēr tiek pārveidoti par virkni "Masīvs" tāpēc jūs nevarat parādīt masīva saturu ( masīvs), izmantojot atbalss vai drukāt lai redzētu, ko tas satur. Lai skatītu atsevišķu vienumu, izmantojiet kaut ko līdzīgu echo $ arr ["foo"]... Tālāk skatiet padomus, kā parādīt/skatīt visu saturu.

Lai pārveidotu mainīgo par tipu "Objekts" tipā virkne tiek izmantota maģiskā metode __toString.

Nozīme NULL vienmēr pārvērš par tukšu virkni.

Kā redzat iepriekš, tieša konvertēšana uz masīvu, objektu vai resursu virkni nesniedz nekādu noderīgu informāciju par pašām vērtībām, izņemot to veidus. Labāks veids, kā izvadīt vērtības atkļūdošanai, ir izmantot funkcijas print_r () un var_dump ().

Lielāko daļu PHP vērtību var pārveidot par virkni pastāvīgai glabāšanai. Šo metodi sauc par serializāciju, un to var veikt, izmantojot funkciju serializēt ().

Virkņu pārvēršana skaitļos

Ja virkne tiek atpazīta kā skaitliska vērtība, iegūtā vērtība un veids tiek noteikti, kā parādīts tālāk.

Ja virknē nav nevienas no rakstzīmēm ".", "E" vai "E", un skaitļa vērtība tiek ievietota veselu skaitļu diapazonā (definēts PHP_INT_MAX), virkne tiks atpazīta kā vesels skaitlis ( vesels skaitlis). Visos citos gadījumos to uzskata par peldošā komata skaitli ( peldēt).

Vērtību nosaka virknes sākums. Ja virkne sākas ar derīgu skaitlisku vērtību, šī vērtība tiks izmantota. Pretējā gadījumā vērtība būs 0 (nulle). Derīga skaitliskā vērtība ir viens vai vairāki cipari (kas var saturēt decimālzīmi), pirms kuriem pēc izvēles ir zīme, kam seko neobligāts eksponents. Eksponents ir "e" vai "E", kam seko viens vai vairāki cipari.

$ foo = 1 + "10,5"; // $ foo ir peldošs (11.5)
$ foo = 1 + "-1.3e3"; // $ foo ir peldošs (-1299)
$ foo = 1 + "bob-1.3e3"; // $ foo ir vesels skaitlis (1)
$ foo = 1 + "bob3"; // $ foo ir vesels skaitlis (1)
$ foo = 1 + "10 mazas cūkas"; // $ foo ir vesels skaitlis (11)
$ foo = 4 + "10,2 mazie cūciņas"; // $ foo ir peldošs (14.2)
$ foo = "10,0 cūkas" + 1; // $ foo ir peldošs (11)
$ foo = "10,0 cūkas" + 1,0; // $ foo ir peldošs (11)
?>

Papildinformāciju par šo konvertēšanu skatiet Unix dokumentācijas sadaļā strtod (3).

Ja vēlaties pārbaudīt kādu no šajā sadaļā minētajiem piemēriem, kopējiet un ielīmējiet to un šo rindiņu, lai redzētu, kas notiek:

echo "\ $ foo == $ foo; ierakstiet:". gettype ($ foo). "
\ n ";
?>

Negaidiet, ka iegūsit rakstzīmju kodu, pārvēršot to veselā skaitlī (kā tas tiek darīts, piemēram, C). Lai pārvērstu rakstzīmes to ASCII kodos un otrādi, izmantojiet funkcijas pasūtījums () un chr ().

Virknes veida ieviešanas informācija

pirms 7 gadiem

Dokumentācijā nav minēts, bet beigu semikolu heredoc beigās faktiski interpretē kā īstu semikolu, un tāpēc dažreiz tas izraisa sintakses kļūdas.

$ foo =<<abcd
BEIGAS;
?>

Tas nenodrošina:

foo (<<abcd
BEIGAS;
);
// sintakses kļūda, neparedzēta ";"
?>

Bez semikola tas darbojas labi:

foo (<<abcd
BEIGAS
);
?>

pirms 3 gadiem

Varat izmantot virkni, piemēram, zīmju masīvu (piemēram, C)

$ a = "String masīva pārbaude";

var_dump ($ a);
// Atgriezt virkni (17) "String array test"

var_dump ($ a);
// Atgriešanas virkne (1) "S"

// - Ar masīva apraidi -
var_dump ((masīvs) $ a);
// Atgriezt masīvu (1) (=> virkne (17) "String array test")

var_dump ((masīvs) $ a);
// Atgriešanas virkne (17) "S"

Norihiori

pirms 15 gadiem

Varat izmantot sarežģīto sintaksi, lai virknē ievietotu gan objekta rekvizītu, gan objekta metožu vērtību. Piemēram ...
klases ieskaite (
publiskais $ viens = 1;
otrā publiskā funkcija () (
atgriešanās 2;
}
}
$ tests = jauns Tests ();
echo "foo ($ test -> one) bar ($ test -> two ())";
?>
Izvadīs "foo 1 bar 2".

Tomēr jūs nevarat to izdarīt visām vērtībām savā nosaukumvietā. Klases konstantes un statiskās īpašības/metodes nedarbosies, jo kompleksā sintakse meklē "$".
klases ieskaite (
const ONE = 1;
}
echo "foo (Test :: ONE) bar";
?>
Tas izvadīs "foo (Test :: one) bar". Konstantes un statiskās īpašības prasa, lai virkne tiktu sadalīta.

pirms 3 gadiem

Ņemiet vērā, ka saskaņā ar "virknes pārvēršanu skaitļos":

Ja ("123abc" == 123) atbalss "(intstr == int) nepareizi pārbauda kā patiesu.";

// Tā kā viena puse ir skaitlis, virkne tiek nepareizi pārveidota no intstr uz int, kas pēc tam atbilst testa numuram.

// Patiess visiem nosacījumiem, piemēram, if un switch priekšrakstiem (iespējams, arī while cilpas)!

// Tas var būt milzīgs drošības risks, pārbaudot/izmantojot/saglabājot lietotāja ievadi, gaidot un pārbaudot tikai veselu skaitli.

// Šķiet, ka vienīgais labojums ir tas, ka 123 ir virkne kā "123", tāpēc konvertēšana nenotiek.

pirms 6 gadiem

Virknēs esošās nulles (mazākais pārsteigums) netiek uzskatītas par oktālām.
Apsveriet:
$ x = "0123" + 0;
$ y = 0123 + 0;
echo "x ir $ x, y ir $ y"; // izdrukā "x ir 123, y ir 83"
citiem vārdiem sakot:
* avota kodā esošās nulles ciparu literāļos tiek interpretētas kā "oktāls", sk. strtol ().
* sākuma nulles virknēs (piemēram, lietotāja iesniegtie dati), kad (netieši vai tieši) tiek nodoti veselam skaitlim, tiek ignorētas un tiek uzskatītas par decimāldaļām, sk. strtod ().

pirms 10 gadiem

Šis ir vienkāršs uzlaušanas veids, kā ļaut dubultpēdiņās un heredocs ietvert patvaļīgas izteiksmes cirtaini iekavās, tostarp konstantes un citus funkciju izsaukumus:

// Hack deklarācija
funkcija _expr ($ v) (atgriež $ v;)
$ _expr = "_expr";

// Mūsu rotaļu laukums
definēt ("qwe" , "asd");
definēt("zxc", 5 );

$ a= 3 ;
$ b= 4 ;

funkcija c($ a, $ b) (atgriezties$ a+ $ b; }

// Lietojums
atbalss"iepriekš{ $ _ekspr(1 + 2 )} izlikt \ n "; // izvada "pre 3 post"
atbalss"iepriekš{ $ _ekspr(qwe)} izlikt \ n "; // izvada "pre asd post"
atbalss"iepriekš{ $ _ekspr(c($ a, $ b)+ zxc* 2 )} izlikt \ n "; // izvada "pre 17 post"

// Vispārējā sintakse ir ($ _expr (...))
?>

Pirms 2 gadiem

Es domāju, ka būtu noderīgi pievienot šo komentāru, lai informācija vismaz parādītos PHP vietnes pareizajā lapā.

Ņemiet vērā: ja plānojat izmantot dubultpēdiņu virkni ar asociatīvo atslēgu, iespējams, tiks parādīta kļūda T_ENCAPSED_AND_WHITESPACE. Daži to uzskata par vienu no mazāk acīmredzamiem kļūdu ziņojumiem.

Izteiciens, piemēram:

$ augļi= masīvs (
"a"=> "ābols",
"b"=> "banāns",
// utt
);

Drukāt "Tas ir$ augļi[ "a"] "; // T_ENCAPSED_AND_WHITESPACE
?>

noteikti sabruks gabalos.

Varat to atrisināt šādi:

drukāt"Tas ir$ augļi[ a] " ; // noņemiet atslēgu
drukāt"Tas ir${ augļus[ "a"]} " ; // Sarežģīta sintakse
drukāt"Tas ir{ $ augļi[ "a"]} " ; // Sarežģītas sintakses variācijas
?>

Es personīgi dodu priekšroku pēdējai variācijai, jo tā ir dabiskāka un tuvāka tam, kāda būtu izteiksme ārpus virknes.

Nav skaidrs (vismaz man), kāpēc PHP nepareizi interpretē vienu pēdiņu izteiksmē, bet es domāju, ka tam ir kāds sakars ar faktu, ka pēdiņas nav vērtību virknes daļa - kad virkne jau tiek parsēta, pēdiņas vienkārši stājies ceļā ...?

Pirms 2 gadiem

Abiem vajadzētu strādāt :(

klasēTestēšana{
publiska statiska$ VAR= "statisks";
publisks const VAR ="konsts";

Publiskā funkcija saki Sveiki, Statiski() {
atbalss"Sveiki:{ $ šis:: $ VAR} " ;
}

Publiskā funkcija saki HelloConst() {
atbalss"Sveiki:{ $ šis:: VAR)" ; // Parsēšanas kļūda: sintakses kļūda, neparedzēta ")", gaida "["
}
}

$ obj= jaunsTestēšana();
$ obj-> saki Sveiki, Statiski();
$ obj-> saki HelloConst();

pirms 3 gadiem

Kaut ko es piedzīvoju, kas, bez šaubām, kādam palīdzēs. ... ...
Manā redaktorā tas sintakse iezīmēs HTML un $ komentāru:

$ html =<<<"EOD"
$ komentārs
EOD;

Izmantojot šo, tiek parādīta viena un tā pati krāsa:

$ html =<<$ komentārs
EOD;

padarot to daudz vieglāku darbu

pirms 11 gadiem

Lai saglabātu savas domas, nelasi iepriekšējos komentārus par datumiem;)

Ja abas virknes var pārveidot par skaitļiem (("$ a"> "$ b") testā), tad tiek izmantoti iegūtie skaitļi, pretējā gadījumā FULL virknes tiek salīdzinātas pa zīmēm:

var_dump("1.22" > "01.23" ); // bool (false)
var_dump("1.22.00" > "01.23.00" ); // bool (true)
var_dump("1-22-00" > "01-23-00" ); // bool (true)
var_dump((peldēt)"1.22.00" > (peldēt)"01.23.00" ); // bool (false)
?>

sajaukts preg_aizvietot(jaukts raksts, jaukta aizstāšana, jaukts priekšmets [, iekšējais ierobežojums])

Meklē tēmu atbilstības un aizstāj tās ar aizstāšanu. Ja ir norādīts limita parametrs, tad veidnes limita gadījumi tiks aizstāti; ja ierobežojums ir izlaists vai vienāds ar -1, visi parauga gadījumi tiks aizstāti.

Aizstāšana var saturēt atsauces formā \\ n vai (kopš PHP 4.0.4) $ n, dodot priekšroku pēdējam. Katra šāda atsauce tiks aizstāta ar apakšvirkni, kas atbilst iekavās ievietotajam n apakšrakstam "n". N var būt vērtības no 0 līdz 99, un atsauce \\ 0 (vai $ 0) atbilst visam modelim. Apakšraksti ir numurētas no kreisās uz labo, sākot no viena...

Izmantojot aizstājējzīmju aizstāšanu, izmantojot apakšmodeli atsauces, var būt iespējams, ka cipars uzreiz aiz maskas. Šajā gadījumā \\ n apzīmējums rada kļūdu: atsauce uz pirmo apakšmodeli, kam seko skaitlis 1, tiks rakstīts kā \\ 11, kas tiks interpretēts kā atsauce uz vienpadsmito apakšmodeli. Šo neskaidrību var novērst, izmantojot konstrukciju \ $ (1) 1, kas norāda uz izolētu atsauci uz pirmo apakšmodeli, kam seko cipars 1.

Šī piemēra izvade būs šāda:

2003. gada 1. aprīlis

Ja funkcijas izpildes laikā tiek atrasta modeļa atbilstība, tiks atgriezta modificētā priekšmeta vērtība, pretējā gadījumā tiks atgriezta sākotnējā tēma.

Pirmie trīs funkcijas parametri preg_replace () var būt viendimensijas masīvi. Ja masīvs izmanto atslēgas, apstrādājot masīvu, tās tiks ņemtas tādā secībā, kādā tās atrodas masīvā. Masīva taustiņi rakstam un nomaiņai nav obligāti. Ja tomēr nolemjat izmantot indeksus, lai saskaņotu aizstāšanā iesaistītos modeļus un virknes, izmantojiet funkciju ksort () katram no masīviem.

2. piemērs. Masīvu ar skaitliskiem indeksiem izmantošana kā funkciju argumentus preg_replace ()

$ virkne = "Ātrā brūnā lapsa pārlēca pāri slinkajam sunim."$ modeļi [0] = "/ ātri /";
$ raksti [1] = "/ brūns /";
$ modeļi [2] = "/ lapsa /"; $ aizstājēji [2] = "lācis";
$ aizstājēji [1] = "melns";
$ nomaiņas [0] = "lēni" preg_replace ($ modeļi, $ nomaiņas, $ virkne);
?>

Rezultāts:

Lēnais melnais lācis pārlēca slinkajam suni.

Ja priekšmeta parametrs ir masīvs, katram tā elementam tiek veikta aizstājējzīmju meklēšana un aizstāšana. Atgrieztais rezultāts būs arī masīvs.

Ja parametru modelis un aizstāšana ir masīvi, preg_replace () pārmaiņus izgūst elementu pāri no abiem masīviem un izmanto tos meklēšanas un aizstāšanas darbībai. Ja aizstāšanas masīvā ir vairāk elementu nekā raksts, aizstāšanai trūkstošo elementu vietā tiks ņemtas tukšas virknes. Ja raksts ir masīvs un aizstāšana ir virkne, katrs raksta masīva elements tiks meklēts un aizstāts ar modeli (raksts pārmaiņus būs visi masīva elementi, bet aizstāšanas virkne paliek fiksēta). Variantam, kad raksts ir virkne un aizstājējs ir masīvs, nav jēgas.

Modifikators / e maina funkcijas uzvedību preg_replace () tādā veidā, ka aizstāšanas parametrs pēc nepieciešamo aizstāšanu veikšanas tiek interpretēts kā PHP kods un tikai pēc tam tiek izmantots aizstāšanai. Lietojot šo modifikatoru, esiet piesardzīgs: aizstāšanas parametram ir jābūt pareizam PHP kodam, pretējā gadījumā rindā, kurā ir funkcijas izsaukums preg_replace (), rodas sintakses kļūda.

3. piemērs. Aizstāšana ar vairākām veidnēm

$ raksti = masīvs ( "/ (19 | 20) (\ d (2)) - (\ d (1,2)) - (\ d (1,2)) /",
"/ ^ \ s * ((\ w +)) \ s * = /");
$ aizstāt = masīvs ("\\ 3 / \\ 4 / \\ 1 \\ 2", "$ \\ 1 =");
echo preg_replace ($ modeļi, $ aizstāt, "(sākuma datums) = 1999-5-27");
?>

Šis piemērs izvadīs:

Pārvērš visus HTML tagus par lielajiem burtiem

Piemērs 5. HTML uz tekstu pārveidotājs

// $ dokumentam izvadē ir jābūt HTML dokumentam.
// Nepieciešams noņemt visus HTML tagus, javascript sadaļas,
// atstarpes rakstzīmes. Ir arī nepieciešams nomainīt dažus
// HTML entītijas to ekvivalentam.$ meklēšana = masīvs ( ""]*?>.*?"si", // Izgrieziet javaScript
""<[\/\!]*?[^<>] *?> "si", // Noņem HTML tagus
"" ([\ r \ n]) [\ s] + "", // Noņem atstarpes rakstzīmes
"" & (quot | # 34); "i", // Aizstāj HTML entītijas
"" & (amp | # 38); "i",
"" & (lt | # 60); "i",
"" & (gt | # 62); "i",
"" & (nbsp | # 160); "i",
"" & (izņemot | # 161); "i",
"" & (cents | # 162); "i",
"" & (mārciņa | # 163); "i",
"" & (kopēt | # 169); "i",
"" (\ d +); "e"); // interpretēt kā php kodu$ aizstāt = masīvs ("",
"" ,
"\\1" ,
"\"" ,
"&" ,
"<" ,
">" ,
" " ,
chr (161),
chr (162),
chr (163),
chr (169),
"chr (\\ 1)"); $ teksts = preg_replace ($ meklēt, $ aizstāt, $ dokuments);
?>

Tabulas:

1. tabulā ir klientu saraksts.
2. tabulā ir sniegts pakalpojumu saraksts.
3. tabulā ir saraksts ar aktuālajiem pasūtījumiem operatīvajām grupām. Šī tabula tiek regulāri atjaunināta, un tās aizpildīšanai tiek izmantota tīmekļa veidlapa. Tā kā tiek saņemts diezgan daudz pasūtījumu, ieraksti tiek ievadīti tabulā klientu un pakalpojumu ID veidā.

Faktiskā problēma ir tāda, ka tīmekļa veidlapā "pasūtījuma atlase" ir jāparāda trešā tabula, un ID vietā ir jāaizstāj attiecīgie lauki no citām kolonnām.

Kods:
$ query = "IZVĒLĒTIES * NO saraksta";
$ rezultāts = mysql_query ($ vaicājums);
while ($ rinda = mysql_fetch_array ($ rezultāts. // ņemt rezultātus no katras rindas
(echo ""; // drukāt datus
}

CREATE TABLE "table_name" ("id" int (255) NOT NULL AUTO_INCREMENT, "saraksta" teksts (80) NOT NULL, PRIMARY KEY ("id".

INSERT INTO "table_name" ("saraksts") VALUES ("bla-bla")

labākā atbilde $ vaicājums =
"
atlasīt uzņēmumus.Uzņēmums, remonta_veidi.Remonta_veidi, saraksts.komentārs_l
no saraksta
iekšējie pievienoties uzņēmumiem
sarakstā.Kas = uzņēmumi.c_id
iekšējā savienojuma labošanas_veidi
sarakstā. "Kas nepieciešams" = remonta_veidi.r_id
";

Pēdējā laikā diskusijas par PHP valodu par Habré ir reducētas uz sarežģītu sistēmu projektēšanas iespējām, kas nevar vien priecāties. Tomēr, apskatot duci vispazīstamāko tīmekļa ietvaru (Zend Framework, Adept, CakePHP, CodeIgniter, LIMB, Symfony, MZZ un citus), es biju patiesi pārsteigts, atklājot dažus būtiskus trūkumus elementārās optimizācijas ziņā.

Lai šo tēmu padarītu tehniski orientētāku, rezultāti ir sniegti stingrākā formā, kas var nedaudz sarežģīt uztveri.

Tātad, iesim ... Uzdevums ir ārkārtīgi vienkāršs: veikt eksperimentus par stīgu veidošanas ātrumu no apakšvirknēm vienpēdiņās un dubultpēdiņās. Principā šis jautājums būs aktuāls vēl ilgi, pateicoties virkņu apstrādes īpatnībām PHP.

Ir daudz rakstu par pamata skripta optimizāciju gan krievu, gan citās valodās. Tas maz saka par virknēm, bet atzīmē faktu, ka virknes tiek "parsētas" mainīgo un kontroles rakstzīmju dubultpēdiņās (kā oficiālajā dokumentācijā). Pamatojoties uz to, ir loģiski pieņemt, ka dubultpēdiņu virkņu izmantošana darbā būs nedaudz lēnāka nekā tās pašas darbības ar vienas pēdiņas apakšvirknēm.

Papildus mainīgo aizstāšanai virknēs un mainīgo saistīšanai ar apakšvirknēm, PHP ievieš vēl vismaz vienu virkņu veidošanas veidu: darbu ar sprintf funkciju. Ir loģiski pieņemt, ka šī metode būs ievērojami zemāka par "standarta" nevajadzīgās funkcijas izsaukšanas un virknes parsēšanas dēļ.

Vienīgais papildinājums, pirms es iepazīstināju jūs ar testa skripta kodu: jums ir jāapsver 2 iespējamās iespējas strādāt ar virknēm dubultpēdiņās: ņemot vērā vienkāršo un "uzlaboto" kodēšanas stilu. Nevajadzētu pievērst uzmanību tam, ka mainīgie, iespējams, atrodas rindu pašā sākumā - tie ir tikai piemēri:
$ string = "$ _SERVER [" HTTP_HOST "] - nav Uļjanovskas apgabala administrācija. Mēs mīlam krievu valodu un mums nepatīk tie, kas to lieto..."
un
$ string = "($ _SERVER [" HTTP_HOST "]) - nav Uļjanovskas apgabala administrācija. Mēs mīlam krievu valodu un mums nepatīk tie, kas to lieto..."

Tests numur viens.
Nu izskatās, ka visas atrunas ir izdarītas – laiks parādīt darba rezultātus. Testera pirmkodu var atrast.

Ekrānuzņēmumos redzams, ka mana hipotēze neapstiprinājās. Vienīgais pareizais pieņēmums izrādījās par darbu ar stīgām caur sprintf. Ātrākās ir funkcijas, kas darbojas ar dubultpēdiņām.

Pēc īsas situācijas apsvēršanas skaidrojums nāca pats par sevi: visa būtība ir tāda, ka atsauces virkne, kurā tika veikta aizstāšana, ir pārāk īsa: parsētājs, kas iet pa šādu virkni, ir sīkums. Tomēr pat šeit var redzēt, ka mainīgā dabiskā aizstāšana virknē dod priekšrocības salīdzinājumā ar "uzlaboto stilu".
Tas ir arī savienošanas pieejas vājums: ievietoto datu apjoms pārsniedz apakšvirkņu apjomu. No kurienes rodas pieskaitāmās izmaksas, var palasīt jau minētajā habratopā.

Tomēr arī šīs domas bija jāapstiprina. Tam bija nepieciešams otrs tests ar izmaiņām iespējamo iemeslu dēļ, kas minēti šādai neparedzamai (man) uzvedībai. Acīmredzot piektajā versijā (atzīšos, piektajā php versijā es veicu tikai 1 testu: iziet cauri masīva elementiem) ir daudz pielabots.

Tests numur divi.
Otrā hipotēze: atsauces virknes pagarināšana galu galā palielinās to testēšanas funkciju darbības laika procentuālo daļu, kas saistītas ar virkņu veidošanu dubultpēdiņās, salīdzinot ar 1. testa rezultātiem. Teorētiski tā pati situācija ir jāievēro attiecībā uz sprintf funkcijas darbība. Tas, pirmkārt, ir saistīts ar nepieciešamību parsēt virknes un tam veltītā laika palielināšanos. Situācijā ar apakšvirkņu savienošanu vienpēdiņās, domāju, tiks novērots aptuveni tāds pats rezultāts kā pirmajā testā, kas dos nelielu samazinājumu funkcijas pēdiņās_3 () izpildes laika daļai līdz laikam. darbojas viss skripts (bet ne veiktspējas pieaugums).

Secinājumi patiesībā ir tikai pozitīvi un apstiprina hipotēzi. Nedaudz palielinot atsauces virkni, parādās liela slodze, kas samazina funkciju veiktspēju darbam ar dubultpēdiņām un sprintf.

Pareizs izrādījās arī pieņēmums par virknēm vienpēdiņās: pirmajā testā 36,75% vietā, bet otrajā, funkcija pēdiņas_3 () aizņēma 33,76% no skripta izpildes laika.

Praktiskā vērtība.
Vienkāršā izteiksmē, abstrahējoties no datiem, varam secināt: jo garāka ir virkne, kurā ir jāveic aizstāšana, jo lielāka iespēja, ka savienošanas darbība tiks izpildīta ātrāk nekā mainīgā meklēšana dubultpēdiņās. Brīvprātīgie var mēģināt izvēlēties nepieciešamos ievietošanas parametrus (mainīgo skaitu, atsauces virknes garumu, mainīgo virkņu garumu), lai tie atbilstu izpildes laiku vienlīdzībai.

Tas patiesībā arī ir viss. Atliek vien piebilst, ka programmēšanā nav nekādu nieku (to es saku tiem, kam patīk teikt "taupīt uz sērkociņiem" (c) Adelfs). Zinot šādus smalkumus un ņemot tos vērā, varat uzrakstīt kodu, kas tiks optimizēts visos līmeņos;)

PS:
Testi veikti, izmantojot Zend Studio For Eclipse 6.0.0 (iekļauts atkļūdotājs + profilētājs).
PHP versija 5.2.5
Debian Linux OS

PPS:
Es būtu priecīgs, ja kāds publicētu savus šo testu rezultātus. Domāju, ka tas ļaus objektīvāk izvērtēt nepieciešamību izmantot vienu vai otru aizvietošanas metodi virknēs. Būšu pateicīgs arī par veselīgu kritiku par prezentācijas stilu un dizainu.