Nav noslēpums, ka PHP citāti var būt vienkārši vai dubulti. Noskaidrosim, kad daži pēdiņu lietojumi ir piemērotāki.

Atsevišķi pēdiņas

Vienkāršākais veids, kā definēt virkni, ir ievietot tekstu atsevišķās pēdiņās.

Ja tekstā ir jāizmanto viens citāts, tas ir jāaizver ar slīpsvītru (\).

Escape secības atsevišķās pēdiņās nedarbojas.

Vienpēdiņu izmantošanas piemēri:

Dubultās pēdiņas

Ja tekstu iezīmēsiet ar dubultpēdiņām, virkne tiks definēta tāpat kā ar vienpēdiņām. Bet, protams, starp citātiem ir atšķirības.

Situācija ar izplūdušajām pēdiņām ir tāda pati kā ar vienpēdiņām.

Virkne, kas ir ievietota dubultpēdiņās, atpazīst lielāko daļu speciālo rakstzīmju atsoļa secību.

Vissvarīgākā atšķirība ir fakts, ka dubultpēdiņās tiek apstrādāti mainīgie.

Dubulto pēdiņu lietošanas piemēri:

Koncentrēsimies uz to, ka virknes ar dubultpēdiņām apstrādā mainīgos.

Kas notiek, kad tiek apstrādāta virkne? Tulks pārbaudiet katru virkni ar pēdiņām mainīgajiem, t.i. notiek piespiedu parsēšana, kas aizņem papildu laiku. Jā, bieži vien šī ir sekundes daļa, bet pats fakts ir jāsaprot. Tas ir, ja salīdzina vienas virknes apstrādi ar dažādām pēdiņām (protams, bez mainīgajiem), tad virkne ar atsevišķām pēdiņām noteikti tiks apstrādāta ātrāk.

Aprēķini

ProfiPHP vietnē atradu interesantus aprēķinus priekš šī tēma. Autors uzrakstīja vienkāršu skriptu, ar kuru viņš aprēķināja virkņu apstrādes laiku.

Šajā īsajā rakstā ir parādīts, kā un kur to izmantot citāti PHP valodā.

Atsevišķas pēdiņas (apostrofi) PHP

Virknes, kas ietvertas atsevišķās pēdiņās, PHP nekādā veidā neapstrādā. Tas nozīmē, ka atsevišķas pēdiņas apzīmē starp tām ievietoto tekstu tādu, kāds tas ir.

// Pareiza atbalss "Kā iet?"; echo "Kā klājas? $vārds"; echo "Kā iet ar dzīvi?".$vārds; // Nepareiza atbalss "Kā iet? $name";

Speciālās rakstzīmes vienpēdiņās un dubultpēdiņās

Lai nodrošinātu, ka, piemēram, tabulēšanas rakstzīme (\t) tiek interpretēta kā tabulēšanas rakstzīme, nevis kā slīpsvītra un burts t, teksta rindiņa, kurā ir tabulēšanas rakstzīme, ir jāiekļauj dubultpēdiņās. Vienpēdiņās varat izmantot tikai \' un \\. Visas pārējās atsoļa secības (\n, \r, \$ utt.) nav atļautas atsevišķās pēdiņās.

// Nepareiza atbalss "Kā iet?\n"; // Pareiza atbalss "Kā iet?\n";

Lai izvairītos no dubultpēdiņām virknē, ievietojiet pēdiņas pirms atpakaļvērstās slīpsvītras \" .

// Nepareiza atbalss "

Kas notiek?

"; // Pareiza atbalss"

Kas notiek?

"; atbalss"

Kas notiek?

";

Dubultās pēdiņas PHP

Teksts, kas ievietots dubultpēdiņās, tiek traktēts ļoti atšķirīgi. Piemēram, dubultpēdiņās ievietotie mainīgie tiek aizstāti ar to vērtībām. Tas padara kompozīciju ērtu SQL vaicājumi izmantojot dubultās pēdiņas.

$query = "INSERT INTO tabula (post,author,text,date) VALUES ("$id","$author","$text","$date"");

Es neesmu PHP programmēšanas eksperts, bet esmu nedaudz neizpratnē, kāpēc es redzu PHP kodu ar virkni, kas ir ievietota vienpēdiņās un dažreiz arī dubultpēdiņās.

Es tikai zinu, ka .NET vai C valodā, ja tas ir atsevišķās pēdiņās, tas nozīmē, ka tā ir rakstzīme, nevis virkne.

Risinājums

Kas jums būtu jāzina

$a = "vārds"; $b = "mans $a"; == "mans vārds" $c = "mans $a"; != "mans vārds"

PHP lietotāji izmanto vienas pēdiņas, lai definētu nemainīgu virkni, piemēram, "a", "mans vārds", "abc xyz", savukārt dubultpēdiņas izmanto, lai definētu virkni, kurā ir identifikators, piemēram, "a $b $c $d".

Un cita lieta ir

Atbalss "mans vārds";

ātrāk par

Atbalss "mans vārds";

Atbalss "mans". $a;

lēnāk nekā

Atbalss "mans $a";

Tas attiecas uz citām izmantotajām virknēm.

PHP teksts vienpēdiņās tiek uzskatīts par virknes vērtību, savukārt teksts dubultpēdiņās analizēs mainīgos, aizstājot un apstrādājot to vērtību.

$test = "mainīgs"; atbalss "Hello Mr $test"; // izvads būtu: Hello Mr mainīgais echo "Hello Mr $test"; // iznākums būtu: Sveiki Mr $test

Šeit dubultpēdiņa parsē vērtību, un viena pēdiņa tiek uzskatīta par virknes vērtību (neparsējot mainīgo $test).

Abu veidu ligzdotās rakstzīmes ir virknes. Ir ērti izmantot viena veida citātu, lai noslēgtu cita veida citātu. """ un """ . Lielākā atšķirība starp pēdiņu veidiem ir tā, ka ligzdoto identifikatoru atsauces tiek aizstātas dubultpēdiņās, nevis vienpēdiņās.

Vienkāršākais veids, kā definēt virkni, ir ievietot to atsevišķās pēdiņās (simbols " ).

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 slīpsvītru lietojumi tiks interpretēti kā parastas rakstzīmes: tas nozīmē, ka, ja mēģināsit izmantot citas atsoļa secības, piemēram, \r vai \n, tie tiks izvadī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 labi";

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

Atbalss "Vai izdzēsāt C:\\*.*?";

// Izejas: vai izdzēsāt C:\*.*?
echo "Vai izdzēsāt C:\*.*?" ;

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

// Izejas: $expand un $vai nu mainīgie netiek izvērsti
atbalss "$expand un $vairs mainīgie nav izvērsti";
?>

Dubultās pēdiņas

Ja virkne ir ievietota dubultpēdiņās ("), PHP atpazīst vairāk atsoļa secību speciālajām rakstzīmēm:

Escape Sequences

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 rakstzīmes regulārajai izteiksmei oktālo skaitļu sistēmā
\x(1,2)	rakstzīmju secība, kas atbilst rakstzīmes regulārajai izteiksmei heksadecimālajā apzīmējumā

Tāpat kā virknei, kas ievietota atsevišķās pēdiņās, atspēkojot jebkuru rakstzīmi, tiks izvadīta arī pati atpakaļvērstā slīpsvītra. Pirms PHP 5.1.1, atpakaļvērstā slīpsvītra \($var) netika publicēts.

Heredoc

Trešais veids, kā definēt virknes, ir izmantot heredoc sintakse: <<< . 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, aizverot ievietošanu.

Līnija obligāti sāciet ar beigu identifikatoru, t.i. tai jāparādās 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 beigu identifikatora rindā nedrīkst būt citas rakstzīmes, izņemot semikolu ( ; ). Tas nozīmē, ka id nedrīkst būt ievilkts 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 Mac OS X, šis \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 nekad netiek atrasts, tas izraisīs parsēšanas kļūdu ar rindas numuru skripta beigās.

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

1. piemērs Nepareizs piemērs

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

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

2. 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 foo()
{
$this -> foo = "Foo" ;
$this ->
}
}

$foo = jauns foo();
$name = "MansVārds" ;

atbalss<<Mans vārds ir "$name". Es ierakstu $foo -> foo .
Tagad es secinu($foo -> bārs [1]) .
Tam vajadzētu izvadīt lielo burtu "A": \x41
EOT;
?>

Mans vārds ir "Mans Vārds". Es ierakstu Foo. Tagad es izvadu Bar2. Tam vajadzētu izvadīt lielo burtu "A": A

Ir iespējams arī izmantot heredoc sintaksi, lai nodotu datus caur funkciju argumentiem:

Kopš versijas 5.3.0 ir kļuvis iespējams inicializēt statiskos mainīgos un klases rekvizītus/konstantes, izmantojot heredoc sintaksi:

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

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

// Klases īpašības/konstantes
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 līdzīgs heredoc, bet tā iekšpusē netiek veiktas nekādas aizstāšanas. Šis dizains ir ideāli piemērots PHP koda vai citu lielu teksta bloku iegulšanai bez nepieciešamības no tā izvairīties. Šajā ziņā tas ir nedaudz līdzīgs SGML konstrukcijai deklarējot teksta bloku, kas nav paredzēts apstrādei.

Nowdoc ir norādīts ar tādu pašu secību <<< , kas tiek izmantots šeitdoc, bet šāds identifikators 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 attiecas uz beigu identifikatoru.

Piemērs #6 Nowdoc piemērs

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

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

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

$foo = jauns foo();
$name = "MansVārds" ;

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

Šī piemēra izpildes rezultāts:

Mans vārds ir "$name". Es drukāju $foo->foo. Tagad es drukāju ($foo->bar). Tas nedrīkst izvadīt lielo "A": \x41

komentēt:

Atšķirībā no heredoc, nowdoc var izmantot jebkurā kontekstā ar statiskiem datiem. Tipisks klases lauku vai konstantu inicializācijas piemērs:

7. piemērs Statisko datu izmantošanas piemērs

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

komentēt:

PHP 5.3.0 tika pievienots nowdoc atbalsts.

Mainīgo apstrāde

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 ( $ ), tas tver pēc iespējas vairāk rakstzīmju, lai izveidotu derīgu mainīgā nosaukumu. Ja vēlaties norādīt vārda beigas, iekļaujiet mainīgā nosaukumu krokainās iekavās.

$sula = "ābols" ;

echo "Viņš dzēra $ sulas sulu." . PHP_EOL ;
// nedarbojas, "s" ir derīga rakstzīme mainīgā nosaukumam,
// bet mūsu mainīgais ir nosaukts $sula.
atbalss "Viņš dzēra sulu, kas pagatavota no $ sulām." ;
?>

Šī piemēra izpildes rezultāts:

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

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

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

$sulas = array("ābols" , "apelsīns" , "koolaid1" => "violeta" );

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

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

Publisks $smith = "Smits" ;
}

$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žeinu." . PHP_EOL ;
echo "$cilvēki -> Džona sieva sveicināja $cilvēkus -> robertu." . PHP_EOL;
echo " $cilvēki -> roberts sasveicinājās ar diviem $cilvēkiem -> smiths ." ; // Nedarbosies
?>

Šī piemēra izpildes 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 pasveicināja Džeinu Smitu. Džona Smita sieva sveicināja Robertu Paulsenu.Roberts Paulsens sveica abus.

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 ļauj izmantot sarežģītus izteicienus.

Izmantojot šo sintaksi, virknē var attēlot jebkuru skalāra mainīgo, masīva elementu vai objekta rekvizītu, kas piesaistīts virknei. Vienkārši uzrakstiet izteiksmi tādā pašā veidā, kā to darītu ārpus līnijas, un pēc tam ietiniet to { Un } . Tāpēc ka { nevar izvairīties, šī sintakse tiks atpazīta tikai tad, kad $ seko tieši { . 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)
atbalss "Tas ir ( $lieliski )" ;

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

// Darbi
atbalss “Šis laukums ir plašs( $kvadrāts -> platums ) 00 centimetri." ;

// Darbojas, citētie atslēgvārdi darbojas tikai ar cirtainu figūriekavu sintaksi
echo "Tas darbojas: ( $arr [ "key" ]) " ;

// Darbi
echo "Tas darbojas: ( $arr [ 4 ][ 3 ]) " ;

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

// Darbi. Izmantojot daudzdimensiju masīvus iekšēji
// līnijās vienmēr tiek izmantotas cirtainas breketes
echo "Tas darbojas: ( $arr [ "foo" ][ 3 ]) " ;

// Darbi.
echo "Tas darbojas: " . $arr [ "foo" ][ 3 ];

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

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

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

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

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

Izmantojot šo sintaksi, virknēs ir iespējams piekļūt arī objekta rekvizītiem.

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

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

Šī piemēra izpildes 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 {$} , sākot ar PHP 5. Tomēr norādītā vērtība tiks uzskatīta par mainīgā nosaukumu tajā pašā kontekstā kā rinda, kurā tā ir definēta. Izmantojot atsevišķas cirtainas lencēm ( {} ) 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" ;

// Tas darbojas, iznāk: Es gribētu A & W
echo "Es gribētu ($( alus :: softdrink )) \n" ;

// Tas arī darbojas, iznāk: I would like Alexander Keith's
echo "Es gribētu ($( alus :: $ale )) \n" ;
?>

Piekļuve rakstzīmei virknē un tās maiņa

Rakstzīmes virknēs var izmantot un modificēt, norādot to nobīdi no virknes sākuma, sākot no nulles, kvadrātiekavās aiz virknes, piemēram, $str . Padomājiet par virkni šim nolūkam 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: Rakstzīmei virknē var piekļūt arī, izmantojot krokainas figūriekavas, piemēram, $str(42) .

Uzmanību

Mēģinot rakstīt nobīdi aiz līnijas robežām, virkne tiks papildināta ar atstarpēm līdz šai nobīdei. Veidi, kas nav veseli skaitļi, tiks pārveidoti par veseliem skaitļu veidiem. Nepareizs nobīdes veids izraisīs līmeņa kļūdu E_NOTICE. Rakstīšana uz negatīvu nobīdi izraisīs līmeņa kļūdu E_NOTICE, un lasot tas atgriezīs tukšu virkni. Tiek izmantota tikai piešķirtās virknes pirmā rakstzīme. Piešķirot tukšai virknei, tiek piešķirts nulles baits (NULL).

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 nav droša vairāku baitu kodēšanai, un to drīkst darīt tikai ar virknēm viena baita kodējumos, piemēram, ISO-8859-1.

9. 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 = "Šis joprojām ir tests." ;
$last = $str [ strlen ($str ) - 1];

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

?>

Sākot ar PHP 5.4, nobīde virknē ir jānorāda kā vesels skaitlis vai virkne, kas satur ciparus, pretējā gadījumā tiks parādīts brīdinājums. Iepriekš nobīde, ko sniedza virkne, piemēram "foo", bez brīdinājuma tika pārveidots par 0 .

10. piemērs: atšķirības starp PHP 5.3 un 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" ]));
?>

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

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

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

string(1) "b" bool(true) Brīdinājums: Nelegāla virknes nobīde "1.0" mapē /tmp/t.php 7. rindā string(1) "b" bool(false) Brīdinājums: Nelegāla virknes nobīde "x" mapē / tmp/t.php 9. rindā string(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 īsteno noteiktas saskarnes), izmantojot vai {} klusībā atgriezīsies 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 un izvērstās meklēšanas un aizstāšanas, regulārās izteiksmes vai ar Perl saderīgām regulārās izteiksmes funkcijām.

Pārvērst par virkni

Vērtību var pārvērst virknē, izmantojot cast (virkne), vai funkcijas strval(). Izteiksmēs, kurās ir 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 “Tipi” un “Manipulācijas ar tipiem”, turpmākais būs skaidrāks. 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 vienu elementu, izmantojiet kaut ko līdzīgu echo $arr["foo"]. Tālāk skatiet padomus, kā parādīt/skatīt visu saturu.

PHP 4 objekti vienmēr tika pārveidoti par virkni "Objekts". Ja vēlaties parādīt objekta lauku vērtības ( objektu) atkļūdošanas nolūkos lasiet tālāk. Ja vēlaties iegūt vajadzīgā objekta klases nosaukumu, izmantojiet get_class(). Kopš PHP 5 ir kļuvusi pieejama arī metode __toString.

NULL vienmēr tiek pārveidots par tukšu virkni.

Kā redzat iepriekš, masīvu, objektu vai resursu tieša konvertēšana virknē 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 (). Turklāt, ja jūsu PHP instalācijai ir WDDX atbalsts, ir iespējama arī serializācija uz XML struktūru.

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

Ja virkne tiek atpazīta kā skaitliska vērtība, iegūto vērtību un veidu nosaka šādi.

Ja virknē nav nevienas no rakstzīmēm ".", "e" vai "E" un skaitļa vērtība ir 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 rinda 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 pludiņš (11.5)
$foo = 1 + "-1.3e3" ; // $foo ir pludiņš (-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 mazi cūciņas" ; // $foo ir pludiņš (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)
?>

Vairāk Detalizēta informācija Lai iegūtu informāciju par šo konvertēšanu, skatiet sadaļu par strtod(3) Unix dokumentācijā.

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īmes kodu, pārvēršot to veselā skaitlī (kā tas tiek darīts, piemēram, C). Lai pārveidotu rakstzīmes to ASCII kodos un atpakaļ, izmantojiet funkcijas ord() Un chr().

Virknes veida ieviešanas informācija

Virknes veids ( virkne) PHP ir ieviests kā baitu masīvs un vesels skaitlis, kas satur bufera garumu. Tajā nav informācijas par to, kā šos baitus pārvērst rakstzīmēs, atstājot šo uzdevumu programmētāja ziņā. Virknes saturam, piemēram, baitam ar vērtību, nav ierobežojumu 0 ("NUL" baits) var atrasties jebkur (tomēr ņemiet vērā, ka dažas funkcijas, kā norādīts šajā rokasgrāmatā, nav "bināri drošas", t.i., tās var nodot virknes bibliotēkām, kuras ignorē datus pēc NUL baita).

Šāda virknes veida būtība izskaidro, kāpēc PHP nav atsevišķa “baitu” tipa — šo lomu spēlē virknes. Funkcijas, kas atgriež datus, kas nav teksta dati, piemēram, patvaļīga datu straume, kas nolasīta no tīkla ligzdas, joprojām atgriež virknes.

Ņemot vērā faktu, ka PHP nenosaka konkrētu virkņu kodējumu, varētu jautāt, kā tad tiek kodēti virkņu literāļi. Piemēram, līnija "á" ekvivalents "\xE1"(ISO-8859-1), "\xC3\xA1"(UTF-8, normalizācijas forma C), "\x61\xCC\x81"(UTF-8, normalizācijas forma D) vai kāds cits iespējamais attēlojums? Atbilde ir tāda, ka virkne tiks kodēta tā, kā tā ir rakstīta skripta failā. Tādējādi, ja skripts ir rakstīts ISO-8859-1 kodējumā, tad virkne tiks kodēta ISO-8859-1 utt. Tomēr šis noteikums nav spēkā, ja ir iespējots Zend Multibyte režīms: šajā gadījumā skriptu var rakstīt jebkurā kodējumā (vai nu tieši norādītā, vai automātiski noteiktā) un pēc tam konvertēt uz noteiktu iekšējo kodējumu, kas vēlāk tiks izmantots stīgu literāļi. Lūdzu, ņemiet vērā, ka skripta kodējumam (vai iekšējam kodējumam, ja ir iespējots Zend Multibyte) ir daži ierobežojumi: kodējumam gandrīz vienmēr ir jābūt ASCII superkopai, piemēram, UTF-8 vai ISO-8859-1. Ņemiet vērā arī to, ka problēmas var radīt no stāvokļa atkarīgi kodējumi, kuros vienas un tās pašas baitu vērtības var izmantot sākotnējā un ne-sākotnējā maiņas stāvoklī.

Protams, lai virknes funkcijas būtu noderīgas, tām ir jāizdara daži pieņēmumi par virknes kodējumu. Diemžēl starp PHP funkcijām šai problēmai ir diezgan daudz dažādu pieeju:

• Dažas funkcijas pieņem, ka virkne ir kodēta kādā viena baita kodējumā, taču tām nav jāinterpretē baiti kā īpašas rakstzīmes, lai tās darbotos pareizi. Šajā kategorijā ietilpst, piemēram, substr(), strpos(), strlen() Un strcmp (). Vēl viens veids, kā domāt par šīm funkcijām, ir tas, ka tās darbojas ar atmiņas buferiem, t.i. tie strādā tieši ar baitiem un to nobīdēm. kompensācijas.
• Citas funkcijas paredz, ka kodējums tiks nodots kā parametrs, iespējams, pieņemot kādu noklusējuma kodējumu, ja kodēšanas parametrs nav norādīts. Šī funkcija ir
• Visbeidzot, ir funkcijas, kas pieņem, ka virknē tiek izmantots noteikts kodējums, parasti UTF-8. Lielākā daļa funkciju no intl un PCRE paplašinājumiem ietilpst šeit (pēdējā gadījumā tikai tad, kad tiek norādīts modifikators u). Lai gan tas tiek darīts ar nolūku, funkcija utf8_decode() nozīmē UTF-8 kodējumu un utf8_encode()- ISO-8859-1.

Galu galā pareizu programmu rakstīšana, kas darbojas ar Unicode, nozīmē rūpīgi izvairīties no funkcijām, kas nedarbojas ar Unicode un var sabojāt datus, un to vietā izmantot derīgas funkcijas, parasti no paplašinājumiem intl un mbstring. Tomēr ar Unicode spējīgu funkciju izmantošana ir labs sākums. Neatkarīgi no valodas piedāvātajām funkcijām ir jāzina pati Unikoda specifikācija. Piemēram, ja programma pieņem, ka valodā pastāv tikai mazie un lielie burti, tad tā pieļauj lielu kļūdu.

Kāda veida pēdiņas jāizmanto, lai formatētu virknes — apostrofus vai klasiskās dubultpēdiņas?

Apskatīsim atšķirību starp dubultpēdiņām un vienpēdiņām PHP un izmantosim piemērus, lai noskaidrotu, kad kuru lietot.

Speciālo rakstzīmju mainīgie un atsoļa secības, kas atrodamas atsevišķās pēdiņās ievietotajās virknēs, netiek apstrādātas. Ar apostrofiem ieskautās virknes PHP tulks apstrādā daudz ātrāk nekā līdzīgas virknes, ko ieskauj dubultpēdiņas.

Iemesls šeit ir vienkāršs: PHP tulks papildus pārbauda virknes dubultpēdiņās, lai noteiktu mainīgo lielumu klātbūtni, un, ja tie tiek atrasti, tad mainīgā nosaukuma vietā virknē tiek ievietota tā vērtība. Bet apostrofos ietverto rindiņu tulks uztver kā parastu tekstu, un PHP šajās rindās nekādas transformācijas neveic. Es domāju, ka ir skaidrs, ka virkņu apstrāde atsevišķās pēdiņās jebkurā gadījumā būs ātrāka.

Vispirms aprakstīsim, kā definēt virkni, un pēc tam pārbaudīsim, cik daudz ātrāk būs virkņu apstrāde atsevišķās pēdiņās.

Vienkāršākais veids, kā definēt virkni, ir ievietot to atsevišķās pēdiņās ("). Lai izmantotu vienas pēdiņas virknē ar vienpēdiņu, pirms tām ir jābūt atpakaļvērstajai slīpsvītrai (\), tas ir, atsoļai. Ja atpakaļvērstā slīpsvītra ir jāievada pirms viena pēdiņa vai jāatrodas rindas beigās, tas ir jādublē. Ja mēģināsit izvairīties no jebkuras citas rakstzīmes, tiks drukāta arī atpakaļvērstā slīpsvītra.

Tālāk ir sniegts atsevišķu pēdiņu izmantošanas piemērs.
// Izvade: vienkārša virkne
atbalss "Vienkārša virkne";
// Prints: Es esmu šeit
atbalss "es esmu šeit";
// Izvade: netiks ievietota: \n jauna rinda
echo "Tas netiks ievietots:\nnewline";
// Izvades: arī mainīgais $example netiks aizstāts
echo "Arī $example mainīgais netiks aizstāts"; Ja virkne ir ievietota dubultpēdiņās ("), PHP atpazīst liels daudzums speciālo rakstzīmju vadības secības, kā arī aizstāj tās vērtību mainīgā nosaukuma vietā virknē. Tāpat kā ar vienpēdiņām, lai dubultpēdiņās izmantotu dubultpēdiņas, pirms tām ir jābūt slīpsvītrai (\).

Šeit ir dubultpēdiņu izmantošanas piemērs:
// Izvade: vienkārša virkne
atbalss "Vienkārša virkne";
// Rezultāti: Uzņēmums "Snowdrop"
atbalss "Uzņēmums \"Sniegpulkstenīte\"";
// Izvade: tas novedīs pie jaunas rindas
echo "Tas pārtrauks uz jaunu rindu \n";
// Izvade: mainīgais tiks aizstāts
$example = "tiks aizstāts";
atbalss "Mainīgais $piemērs"; Jāatceras arī, ka secība "\n" ( jauna līnija), "\r" (ratu atgriešana) vienkāršam tekstam, nevis HTML. Tātad jūs neredzēsit izmaiņas pārlūkprogrammā (tikai avota kods lapas).

Noskaidrosim, cik daudz ātrākas ir vienas pēdiņas nekā dubultpēdiņas. Mērījumiem mēs uzrakstīsim īsu testa skriptu, un uzreiz atzīmēsim, ka, pārbaudot pats, rezultāti, kas ir atkarīgi no datora vai servera aparatūras, būs atšķirīgi.
// Atgriež laikspiedolu cilpas sākumā
$sākt = mikrolaiks(true);
// Izveidojiet cilpu 1 miljonam iterāciju
priekš ($i = 0; $i< 1000000; $i++) {
$text = "Šeit ir rakstzīmju virkne";
}
// Aprēķināt pavadīto laiku
$laiks = (mikrolaiks(true) - $sākums); Rezultāts: 0,09 sekundes.

Ja vienas pēdiņas aizstājam ar dubultpēdiņām:
$text = "Šeit ir rakstzīmju virkne"; Rezultāts būs 0,10 sekundes.

Kā redzat, izmantojot teksta virknes, izpildes laika atšķirība ir ļoti maza, varētu pat teikt, ka tā nemaz neeksistē. Jautrība sākas, kad mēs cenšamies apvienot virkni un mainīgo.
$text = "Šeit ir rakstzīmju virkne $i"; vai
$teksts = $i."Šeit ir rakstzīmju virkne"; Rezultāts aptuveni: 0,27 sekundes.

Atšķirība ir diezgan jūtama. Savienošana un pēdiņas nepārprotami ietekmē veiktspēju, kad virknei tiek pievienoti mainīgie.

Kad serveris apstrādā kodu, tas pārbauda visu dubultpēdiņu saturu mainīgajiem, konstantēm un citiem. Tas paņem laiku. Un serveris apstrādā to, kas atrodas starp atsevišķām pēdiņām, kā gatavu tekstu un neinteresē, kas tur ir. Atšķirība starp vienpēdiņu un dubultpēdiņu veiktspēju ir ļoti maza, taču, ja izstrādājat ļoti noslogotu projektu, tad dažas ietaupītās milisekundes jau ir uzvara.