komentuoti: PHP 7.0.0 64 bitų platformose nėra pasiekiamų 32 bitų sistemose linijos ilgio apribojimų, o ankstesnėse PHP versijose eilutės negali būti didesnės nei 2 GB (2147483647 baitai).

Sintaksė

Eilutę galima apibrėžti keturiais įvairiais būdais:

• pavienės citatos
• dvigubos kabutės
• nowdoc sintaksė (nuo PHP 5.3.0)

Pavienės citatos

Paprasčiausias būdas apibrėžti eilutę reiškia įterpti ją į atskiras kabutes (simbolis " ).

Jei eilutėje norite naudoti vieną kabutę, palikite ją pasviruoju brūkšniu ( \ ). Jei reikia parašyti patį pasvirąjį brūkšnį, kopijuokite jį ( \\ ). Visi kiti pasvirojo brūkšnio naudojimo būdai bus interpretuojami kaip įprasti simboliai: tai reiškia, kad jei bandysite naudoti kitas pabėgimo sekas, pvz. \r arba \n, jie bus išvesti tokie, kokie yra, o ne bet koks specialus elgesys.

aidas "tai paprasta eilutė";

aidas „Taip pat galite įterpti į eilutes
naujos eilutės simbolis kaip šis,
Tai gerai";

// Išėjimai: Arnoldas kartą pasakė: "Aš grįšiu"
aidas „Vieną dieną Arnoldas pasakė: „Aš grįšiu“.;

Aidas "Ar ištrynėte C:\\*.*?";

// Išėjimai: ar ištrynėte C:\*.*?
echo "Ar ištrynėte C:\*.*?" ;

// Išėjimai: Tai nebus išplėsta: \n nauja eilutė
aidas "Tai nebus išplėsta: \n nauja eilutė";

// Išėjimai: $expand ir $ether kintamieji neišplečiami
aidas "$expand ir $arba kintamieji nėra išplėsti";
?>

Dvigubos kabutės

Jei eilutė yra dvigubose kabutėse ("), PHP atpažįsta šias specialiųjų simbolių pabėgimo sekas:

Kaip ir eilutę, įterptą į pavienes kabutes, pašalinus bet kurį simbolį taip pat bus išvedamas pats pabėgimo simbolis. Prieš PHP 5.1.1, pasvirasis brūkšnys \($var) nebuvo paskelbta.

Heredoc

Trečias būdas apibrėžti eilutes yra naudoti heredoc sintaksę: <<< . Po šiuo operatoriumi turite nurodyti identifikatorių, tada eilutės tiekimą. Po to ateina pati eilutė, o tada tas pats identifikatorius, uždarantis įterpimą.

Linija turėtų pradėti nuo uždarymo identifikatoriaus, t.y. jis turi būti nurodytas pirmajame eilutės stulpelyje. Be to, identifikatorius turi laikytis tų pačių pavadinimo taisyklių, kaip ir visos kitos PHP žymos: jame turi būti tik raidiniai ir skaitiniai simboliai bei apatinis brūkšnys ir negali prasidėti skaičiumi (leistini pabraukimai).

Dėmesio

Labai svarbu atkreipti dėmesį, kad baigiamojoje identifikatoriaus eilutėje neturi būti jokių kitų simbolių, išskyrus kabliataškį ( ; ). Tai reiškia, kad ID neturėtų būti įtraukta ir kad prieš arba po kabliataškio negali būti tarpų ar skirtukų. Taip pat svarbu suprasti, kad pirmasis simbolis prieš uždarymo identifikatorių turi būti naujos eilutės simbolis, kaip apibrėžta jūsų operacinėje sistemoje. Pavyzdžiui, UNIX sistemose, įskaitant „MacOS“, tai yra \n. Po uždarymo identifikatoriaus iš karto taip pat turi prasidėti nauja eilutė.

Jei ši taisyklė pažeista ir uždarymo identifikatorius nėra „švarus“, daroma prielaida, kad uždarymo identifikatoriaus nėra ir PHP toliau jo ieškos. Jei šiuo atveju teisingas uždarymo identifikatorius niekada nerastas, tai sukels analizavimo klaidą su eilutės numeriu scenarijaus pabaigoje.

1 pavyzdys Neteisingos sintaksės pavyzdys

klasė foo (
viešas $baras =<<baras
EOT;
// įtrauka prieš uždarymo identifikatorių neleidžiama
}
?>

2 pavyzdys Tinkamos sintaksės pavyzdys

klasė foo (
viešas $baras =<<baras
EOT;
}
?>

Heredoc negalima naudoti klasės laukams inicijuoti.

Heredoc tekstas elgiasi taip pat, kaip eilutė dvigubose kabutėse, jų neturint.

Tai reiškia, kad nereikia naudoti pabėgimo kabučių heredoc, bet vis tiek galite naudoti aukščiau esančias pabėgimo sekas.

Kintamieji yra apdorojami, bet jūs turite būti tokie pat atsargūs, kai naudojate sudėtingus kintamuosius heredoc viduje, kaip ir dirbdami su eilutėmis.<<3 pavyzdys Heredoc eilutės apibrėžimo pavyzdys
$str =
eilutės pavyzdys,
apimantis kelias linijas,

naudojant heredoc sintaksę.
{
EOD;
Klasė foo

var $foo ;
{
var $bar ;
Function__construct()
}
}

$this -> foo = "Foo" ;
$tai ->

$foo = naujas foo();<<$name = "Vardas" ; .
aidas Mano vardas yra "$name". Įvedu $foo -> foo .
Dabar darau išvadą
EOT;
?>

($foo -> baras [1])

Tai turėtų išvesti didžiąją raidę "A": \x41

Mano vardas "Vardas". Rašau Foo. Dabar išvedu Bar2. Tai turėtų išvesti didžiąją raidę "A": A

Taip pat galima naudoti heredoc sintaksę duomenims perduoti per funkcijos argumentus:

Nuo 5.3.0 versijos tapo įmanoma inicijuoti statinius kintamuosius ir klasės ypatybes/konstantas naudojant heredoc sintaksę:
5 pavyzdys. Heredoc naudojimas statiniams kintamiesiems inicijuoti
{
// Statiniai kintamieji<<funkcija foo()
statinė $bar =
}

Nieko čia nėra...
ETIKETĖ;
{
// Konstantos/klasės savybės<<klasė foo
const BAR =

Konstantos naudojimo pavyzdys<<FOOBAR;
const BAR =
}
?>

Viešas $baz =

Lauko naudojimo pavyzdys

Nuo PHP 5.3.0 Heredoc identifikatorių taip pat galite įvesti dvigubomis kabutėmis: Dabardoc„Nowdoc“ yra tas pats vienkartinėms eilutėms, kaip „heredoc“ yra skirtas eilutėms su dvigubomis kabutėmis. Nowdoc yra panašus į heredoc, bet jo viduje keitimai neatliekami

. Šis dizainas idealiai tinka PHP kodui ar kitiems dideliems teksto blokams įterpti be reikalo. Šiuo atžvilgiu jis yra šiek tiek panašus į SGML konstrukciją <<< paskelbiant teksto bloką, kurio neketinama apdoroti. <<<"EOT" Nowdoc žymimas ta pačia seka

, kuris naudojamas heredoc, bet toliau nurodytas identifikatorius yra atskirose kabutėse, pavyzdžiui,

$foo = naujas foo();<<<"EOD"
.
Visos sąlygos, taikomos heredoc identifikatoriams, taikomos ir nowdoc, ypač tos, kurios taikomos uždarymo identifikatoriui.
7 pavyzdys, kaip naudoti nowdoc
Teksto pavyzdys,
apimantis kelias linijas

naudojant nowdoc sintaksę. Pasvirieji brūkšniai visada traktuojami pažodžiui,

Teksto, apimančio kelias eilutes, naudojant nowdoc sintaksę, pavyzdys. Pasvirieji brūkšniai visada traktuojami pažodžiui, pvz., \\ ir \".

8 pavyzdys Nowdoc eilutės citavimo pavyzdys su kintamaisiais

/* Sudėtingesnis pavyzdys su kintamaisiais. */
ETIKETĖ;
{
viešas $foo ;
viešas $baras ;

var $foo ;
{
var $bar ;
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}

$this -> foo = "Foo" ;
$tai ->

$foo = naujas foo();<<<"EOT"
Mano vardas yra "$name". Spausdinu $foo->foo.
Dabar spausdinu ($foo->bar).
Tai neturėtų išvesti didžiosios raidės „A“: \x41
EOT;
?>

naudojant nowdoc sintaksę. Pasvirieji brūkšniai visada traktuojami pažodžiui,

Mano vardas „$name“. Spausdinu $foo->foo. Dabar spausdinu ($foo->bar). Tai neturėtų išvesti didžiosios raidės „A“: \x41

9 pavyzdys Statinių duomenų naudojimo pavyzdys

klasė foo (
viešas $baras =<<<"EOT"
baras
EOT;
}
?>

komentuoti:

„nowdoc“ palaikymas buvo įtrauktas į PHP 5.3.0.

Kintamųjų tvarkymas

Jei eilutė nurodyta dvigubose kabutėse arba naudojant heredoc, joje esantys kintamieji apdorojami.

Yra dviejų tipų sintaksė: paprasta ir sudėtinga. Paprasta sintaksė yra lengvesnė ir patogesnė. Tai leidžia apdoroti kintamąjį, masyvo reikšmę ( masyvas ) arba objekto savybes ( objektas

) su minimaliomis pastangomis.

Sudėtingą sintaksę galima atpažinti pagal išraišką supančius skliaustus.

Paprasta sintaksė $ Jei vertėjas susiduria su dolerio ženklu (

), ji užfiksuoja kuo daugiau simbolių, kad susidarytų tinkamas kintamojo pavadinimas. Jei norite nurodyti vardo pabaigą, kintamojo pavadinimą įtraukite į riestinius skliaustus.

$sultys = "obuoliai" ;

echo "Jis išgėrė šiek tiek $ sulčių sulčių." . PHP_EOL ;
// Neteisingai. „s“ yra tinkamas kintamojo pavadinimo simbolis, tačiau kintamasis pavadintas $juice.

echo "Jis gėrė sultis iš $ sulčių." ;
// Teisingai. Kintamojo pavadinimo pabaiga griežtai nurodoma skliausteliuose:
?>

naudojant nowdoc sintaksę. Pasvirieji brūkšniai visada traktuojami pažodžiui,

echo "Jis gėrė sultis iš $( sulčių ) s." ;

Jis išgėrė obuolių sulčių. Jis gėrė sultis iš . Jis gėrė sultis iš obuolių. Paprasta sintaksė yra lengvesnė ir patogesnė. Tai leidžia apdoroti kintamąjį, masyvo reikšmę ( Masyvo elementas ( ) arba objekto savybes () arba objekto nuosavybė ( ] ). Masyvo indeksuose yra baigiamasis laužtinis skliaustas (

) žymi rodyklės apibrėžimo pabaigą. Objekto savybėms taikomos tos pačios taisyklės kaip ir paprastiems kintamiesiems.

10 pavyzdys Paprastas sintaksės pavyzdys
define ("KOOLAID" , "koolaid1" );

$sultys = array("obuolių" , "apelsinų" , "koolaid1" => "violetinė" );
echo "Jis išgėrė $ sulčių [ 0 ] sulčių." . PHP_EOL ;
echo "Jis išgėrė $ sulčių [ 1 ] sulčių." . PHP_EOL ;

echo "Jis išgėrė $ sulčių [ koolaid1 ] sulčių." . PHP_EOL ;
klasės žmonės (
viešas $džonas = "Jonas Smitas" ;
vieša $jane = "Jane Smith" ;

viešasis $robertas = "Robertas Paulsenas" ;
}

Viešas $kalvis = "Smith" ;

echo "$žmonės -> Džonas išgėrė $sulčių [ 0 ] sulčių." . PHP_EOL ;
echo " $žmonės -> Džonas tada pasisveikino su $žmonėmis -> Jane." . PHP_EOL ;
echo "$žmonės -> Jono žmona pasveikino $žmones -> robertą." . PHP_EOL;
echo " $žmonės -> Robertas pasveikino du $žmones -> kalvius." ; // Nepavyks
?>

naudojant nowdoc sintaksę. Pasvirieji brūkšniai visada traktuojami pažodžiui,

Jis išgėrė obuolių sulčių. Jis išgėrė šiek tiek apelsinų sulčių. Jis išgėrė purpurinių sulčių. Džonas Smitas išgėrė obuolių sulčių. Tada Johnas Smithas pasisveikino su Jane Smith. Johno Smitho žmona pasveikino Robertą Paulseną.

Pridėtas PHP 7.1.0 palaikymas neigiamas skaitiniai indeksai.

11 pavyzdys Neigiami skaitiniai indeksai

$string = "eilutė" ;
aidas "Simbolis indekse -2 yra lygus$eilutė [- 2 ]." , PHP_EOL ;
$string [- 3 ] = "o" ;
aidas "Pakeitus simbolį padėtyje -3 į "o", gaunama tokia eilutė:$string." , PHP_EOL;
?>

naudojant nowdoc sintaksę. Pasvirieji brūkšniai visada traktuojami pažodžiui,

Simbolis su indeksu -2 yra lygus n. Pakeitus simbolį -3 padėtyje į "o", gaunama tokia eilutė: stiprus

Sudėtingesniems dalykams naudokite sudėtingą sintaksę.

Sudėtinga (garbanota) sintaksė

Jis vadinamas kompleksiniu ne todėl, kad jį sunku suprasti, o todėl, kad leidžia vartoti sudėtingus posakius.

Bet koks skaliarinis kintamasis, masyvo elementas arba objekto ypatybė, susieta su eilute, gali būti pavaizduota eilutėje naudojant šią sintaksę. Tiesiog parašykite išraišką taip pat, kaip parašytumėte už eilutės ribų, tada apvyniokite ją { Ir } . Kadangi { Ši sintaksė bus atpažįstama tik tada, kai $ seka tiesiogiai { . Naudokite {\$ spausdinti {$ .

Keletas iliustruojančių pavyzdžių:
// Rodyti visas klaidas

error_reporting (E_ALL);

$puikus = "puiku" ;
// Neveikia, išeina: tai yra (puiku)

echo "Tai yra ( $puikus )" ;
// Darbai, išėjimai: Tai puiku

echo "Tai ( $puikus ) " ;
aidas // Darbai„Ši aikštė plati

( $kvadratas -> plotis ) 00 centimetrų." ;
// Veikia, kabutiniai raktiniai žodžiai veikia tik su garbanotųjų skliaustų sintaksė

echo "Tai ( $puikus ) " ;
echo "Tai veikia: ( $arr [ "raktas" ]) " ;

echo "Tai veikia: ( $arr [ 4 ][ 3 ]) " ;
// Tai negalioja dėl tos pačios priežasties kaip $foo out
// eilutės. Kitaip tariant, jis vis tiek veiks,
// bet kadangi PHP pirmiausia ieško pastovaus foo, tai sukels
aidas // lygio klaida E_NOTICE (neapibrėžta konstanta)."Tai neteisinga:

( $arr [ foo ][ 3 ]) " ;
// Darbai. Viduje naudojant daugiamačius masyvus
// linijose visada naudojami garbanoti breketai

echo "Tai veikia: ( $arr [ "foo" ][ 3 ]) " ;
// Darbai.

aidas echo "Tai veikia: " . $arr [ "foo" ][ 3 ];( $obj -> reikšmės [ 3 ]-> pavadinimas ) " ;

aidas "Tai yra pavadinto kintamojo reikšmė$vardas : ($( $vardas )) " ;

aidas Tai yra kintamojo pavadinimo reikšmė, kurią grąžina getName():($( getName ())) " ;

aidas "Tai yra kintamojo pagal pavadinimą reikšmė, kurią grąžina \$object->getName():($( $objektas -> getName ())) " ;

// Neveikia, išveda: Štai ką getName() grąžina: (getName())
aidas „Štai ką grąžina getName(): (getName())“;
?>

Taip pat naudojant šią sintaksę galima pasiekti objekto ypatybes eilutėse.

klasė foo (
var $bar = "Aš esu baras." ;
}

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

naudojant nowdoc sintaksę. Pasvirieji brūkšniai visada traktuojami pažodžiui,

Aš esu baras. Aš esu baras.

komentuoti:

Funkcijos, metodų iškvietimai, statiniai klasių kintamieji ir klasių konstantos veikia viduje {$} , pradedant PHP 5. Tačiau pateikta reikšmė bus traktuojama kaip kintamojo pavadinimas tame pačiame kontekste kaip ir eilutė, kurioje ji apibrėžta. Vienų garbanotų petnešų naudojimas ( {} ) neveiks norint pasiekti funkcijų, metodų, klasių konstantų ar statinių klasės kintamųjų vertes.

Keletas iliustruojančių pavyzdžių:
// Rodyti visas klaidas

klasės alus (
const gaivusis gėrimas = "rootbeer" ;
public static $ale = "ipa" ;
}

$rootbeer = "A & W" ;
$ipa = "Aleksandras Keitas" ;

// Tai veikia, išvesta: Norėčiau A ir W
echo "Norėčiau ($( beers :: soft drink )) \n" ;

// Tai taip pat veikia, išeina: I would like Alexander Keith's
echo "Norėčiau ($( beers :: $ale )) \n" ;
?>

Simbolio prieiga ir keitimas eilutėje

Simboliai eilutėse gali būti naudojami ir modifikuojami nurodant jų poslinkį nuo eilutės pradžios, pradedant nuo nulio, laužtiniuose skliaustuose po eilutės, pavyzdžiui, $str . Pagalvokite apie šiam tikslui skirtą eilutę kaip simbolių masyvą. Ir Jei reikia gauti arba pakeisti daugiau nei 1 simbolį, galite naudoti funkcijas.

komentuoti: substr() substr_replace() Nuo PHP 7.1.0 palaikomos neigiamos poslinkio reikšmės. Jie nurodo poslinkį nuo eilutės pabaigos. Anksčiau neigiami poslinkiai sukėlė lygio paklaidą E_NOTICE

komentuoti: skaitymo metu (grąžinant tuščią eilutę) arba

Dėmesio

E_ĮSPĖJIMAS Jie nurodo poslinkį nuo eilutės pabaigos. Anksčiau neigiami poslinkiai sukėlė lygio paklaidą.

Dėmesio

Naudojamas tik pirmasis priskirtos eilutės simbolis.

komentuoti: Nuo PHP 7.1.0 priskyrus tuščią eilutę sukels mirtiną klaidą. Anksčiau šiuo atveju buvo priskirtas nulinis baitas (NULL).

PHP eilutės yra baitų masyvai. Dėl to prieiga prie eilutės ar jos modifikavimas su poslinkiu nėra saugus kelių baitų koduotėje ir tai turėtų būti atliekama tik naudojant vieno baito kodavimo eilutes, pvz., ISO-8859-1.

Kadangi PHP 7.1.0, tuščio indekso naudojimas sukelia mirtiną klaidą, šiuo atveju eilutė buvo konvertuojama į masyvą be įspėjimo.
12 pavyzdys Keletas pavyzdinių eilučių
// Gaukite pirmąjį eilutės simbolį

$str = "Tai testas." ;
$pirmas = $str [0];

// Gaukite trečiąjį eilutės simbolį
$trečias = $str [ 2 ];
// Gaukite paskutinį eilutės simbolį

$str = "Tai vis dar bandymas." ;
$last = $str [ strlen ($str ) - 1 ];
// Pakeiskite paskutinį eilutės simbolį

?>

$str = "Pažvelk į jūrą" ; $str [ strlen ($str )- 1 ] = "e" ; Nuo PHP 5.4 versijos poslinkis eilutėje turi būti nurodytas kaip sveikasis skaičius arba eilutė su skaitmenimis, kitaip bus pateiktas įspėjimas. Anksčiau poslinkis, suteiktas eilute patinka 0 .

"foo"

, be įspėjimo buvo paverstas į

13 pavyzdys PHP 5.3 ir PHP 5.4 skirtumai
$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" ]));

Šio pavyzdžio vykdymo PHP 5.3 rezultatas:

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

komentuoti:

Šio pavyzdžio vykdymo PHP 5.4 rezultatas: string(1) "b" bool(true) Įspėjimas: Neteisėtas eilutės poslinkis "1.0" /tmp/t.php 7 eilutėje string(1) "b" bool(false) Įspėjimas: Neteisėtas eilutės poslinkis "x" / tmp/t.php 9 eilutėje string(1) "a" bool(false) string(1) "b" bool(false) {} Bandymas pasiekti kitų tipų kintamuosius (išskyrus masyvus ar objektus, kurie įgyvendina tam tikras sąsajas) naudojant arba.

komentuoti:

tyliai grįš NULL {} .

PHP 5.5 pridėjo palaikymą prieigai prie simbolių eilučių literaluose naudojant sintaksę

arba

Yra daug naudingų eilučių modifikavimo funkcijų.

Pagrindinės funkcijos aprašytos skyriuje apie eilučių funkcijas, o išplėstinės paieškos ir keitimo – su Perl suderinamos reguliariosios išraiškos funkcijos. Konvertuoti į eilutę Reikšmė gali būti konvertuojama į eilutę naudojant cast strval(). aidas string(1) "b" bool(true) Įspėjimas: Neteisėtas eilutės poslinkis "1.0" /tmp/t.php 7 eilutėje string(1) "b" bool(false) Įspėjimas: Neteisėtas eilutės poslinkis "x" / tmp/t.php 9 eilutėje string(1) "a" bool(false) string(1) "b" bool(false) Posakiuose, kur reikalinga eilutė, konvertavimas įvyksta automatiškai. Taip atsitinka, kai naudojate funkcijas spausdinti.

, arba kai kintamojo reikšmė lyginama su eilute. Perskaičius vadovo skirsnius „Tipai“ ir „Tipu manipuliavimas“, viskas bus aiškiau. Taip pat žr settype () Masyvai visada konvertuojami į eilutę Paprasta sintaksė yra lengvesnė ir patogesnė. Tai leidžia apdoroti kintamąjį, masyvo reikšmę ("Masyvas" aidas NULL Posakiuose, kur reikalinga eilutė, konvertavimas įvyksta automatiškai., todėl negalite rodyti masyvo turinio ( ), naudojant kad pamatytumėte, kas jame yra. Norėdami peržiūrėti vieną elementą, naudokite kažką panašaus

echo $arr["foo"] . Žemiau rasite patarimų, kaip rodyti / peržiūrėti visą turinį. Norėdami konvertuoti tipo kintamąjį "Objektas" tipo

styga arba Naudojamas magiškas metodas __toString.

Reikšmė visada konvertuojamas į tuščią eilutę. Ir Kaip matote aukščiau, tiesioginis masyvų, objektų ar išteklių konvertavimas į eilutę nesuteikia jokios naudingos informacijos apie pačias vertes, išskyrus jų tipus..

Geresnis būdas išvesti derinimo vertes yra naudoti funkcijas print_r().

var_dump()

Daugumą PHP reikšmių galima konvertuoti į eilutę nuolatiniam saugojimui. Šis metodas vadinamas serializavimu ir gali būti atliktas naudojant funkciją

serializuoti () Eilučių konvertavimas į skaičius Jei eilutė atpažįstama kaip skaitinė reikšmė, gauta reikšmė ir tipas nustatomi taip. Jei eilutėje nėra jokių simbolių „.“, „e“ arba „E“, o skaičiaus reikšmė patenka į sveikųjų skaičių ribas (apibrėžta PHP_INT_MAX ), eilutė bus atpažinta kaip sveikasis skaičius ().

sveikasis skaičius

). Visais kitais atvejais jis laikomas slankiojo kablelio skaičiumi (
plūduriuoti Reikšmė nustatoma pagal eilutės pradžią. Jei eilutė prasideda galiojančia skaitine reikšme, ta reikšmė bus naudojama. Priešingu atveju reikšmė bus 0 (nulis). Tinkama skaitinė reikšmė yra vienas ar daugiau skaitmenų (kuriuose gali būti dešimtainis kablelis), prieš kurį pasirinktinai rašomas ženklas, po kurio eina neprivalomas rodiklis. Rodiklis yra "e" arba "E", po kurio eina vienas ar daugiau skaitmenų.
$foo = 1 + "10,5" ;
// $foo yra plūdė (11.5)
$foo = 1 + "-1.3e3" ; // $foo yra plūdė (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo yra sveikasis skaičius (1) $foo = 1 + "bob3" ; // $foo yra sveikasis skaičius (1)
$foo = 1 + "10 mažų kiaulių" ;
// $foo yra sveikasis skaičius (11)
?>

Daugiau informacijos apie šį konvertavimą rasite Unix dokumentacijos skyriuje strtod(3).

Jei norite išbandyti kurį nors iš šiame skyriuje pateiktų pavyzdžių, nukopijuokite ir įklijuokite jį bei šią eilutę, kad pamatytumėte, kas atsitiks:

echo "\$foo== $foo ; įveskite: " . gettype ($foo) . “
\n" ;
?>

Nesitikėkite, kad gausite simbolio kodą konvertuodami jį į sveikąjį skaičių (kaip daroma, pavyzdžiui, C). Norėdami konvertuoti simbolius į jų ASCII kodus ir atgal, naudokite funkcijas ord () Ir chr().

Išsami eilutės tipo diegimo informacija

prieš 7 metus

Dokumentuose neminimas, bet baigiamasis kabliataškis heredoc pabaigoje iš tikrųjų interpretuojamas kaip tikras kabliataškis, todėl kartais atsiranda sintaksės klaidų.

$foo =<<abcd
PABAIGA;
?>

Tai nereiškia:

foo (<<abcd
PABAIGA;
);
// sintaksės klaida, netikėta ";"
?>

Be kabliataškio jis veikia gerai:

foo (<<abcd
PABAIGA
);
?>

prieš 3 metus

Galite naudoti eilutę kaip simbolių masyvą (pvz., C)

$a = "Eilutės masyvo testas";

var_dump($a);
// Grąžina eilutę(17) "Eilutės masyvo testas"

var_dump($a);
// Grąžinama eilutė(1) "S"

// -- Su masyvo atidavimu --
var_dump((masyvas) $a);
// Grąžina masyvą(1) ( => string(17) "Eilutės masyvo testas")

var_dump((masyvas) $a);
// Grąžinama eilutė(17) "S"

Norihiori

prieš 15 metų

Galite naudoti sudėtingą sintaksę, kad į eilutę įtrauktumėte objekto ypatybių IR objekto metodų vertę. Pavyzdžiui...
klasės testas (
viešasis $ vienas = 1 ;
viešoji funkcija antra() (
grąžinimas 2;
}
}
$testas = new Test();
echo "foo ( $test -> one ) bar ( $test -> two ()) " ;
?>
Išves „foo 1 bar 2“.

Tačiau negalite to padaryti visoms jūsų vardų erdvėje esančioms reikšmėms. Klasės konstantos ir statinės savybės / metodai neveiks, nes sudėtinga sintaksė ieško „$“.
klasės testas (
const VIENAS = 1;
}
echo "foo (Test::ONE) bar" ;
?>
Bus išvesta „foo (Test::one) bar“. Konstantos ir statinės savybės reikalauja išskaidyti eilutę.

prieš 3 metus

Atkreipkite dėmesį, kad pagal „Eilutės konvertavimą į skaičius“:

Jei ("123abc" == 123 ) aidas "(intstr == int) neteisingai patikrina kaip teisingą.";

// Kadangi viena pusė yra skaičius, eilutė neteisingai konvertuojama iš intstr į int, o tai sutampa su testo numeriu.

// Tiesa visiems sąlyginiams sakiniams, pvz., if ir switch sakiniams (tikriausiai ir while ciklams)!

// Tai gali būti didžiulė saugumo rizika, kai tikrinama/naudojama/išsaugoma vartotojo įvestis, o tikimasi ir tikrinamas tik sveikasis skaičius.

// Atrodo, kad vienintelis pataisymas yra tai, kad 123 būtų eilutė kaip "123", todėl konversija neįvyksta.

?>

prieš 6 metus

Pirmieji nuliai eilutėse (mažiausiai stebina) nelaikomi aštuntainiais.
Apsvarstykite:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x yra $x, y yra $y"; //spausdina "x yra 123, y yra 83"
kitaip tariant:
* pirmieji nuliai skaitiniuose literaluose šaltinio kode yra interpretuojami kaip „aštuontainė“, plg. strtol ().
* priekiniai nuliai eilutėse (pvz., vartotojo pateikti duomenys), kai (netiesiogiai arba tiesiogiai) perkeliami į sveikąjį skaičių, yra ignoruojami ir laikomi dešimtainiais, žr. strtod().

prieš 10 metų

Čia yra paprastas įsilaužimas, leidžiantis dvigubomis kabutėmis ir heredocs turėti savavališkas išraiškas lenktų skliaustų sintaksėje, įskaitant konstantas ir kitus funkcijų iškvietimus:

// Nulaužimo deklaracija
funkcija _expr ($v ) ( grąžinti $v ; )
$_expr = "_expr" ;

// Mūsų žaidimų aikštelė
define("qwe" , "asd");
apibrėžti("zxc", 5 );

$a= 3 ;
$b= 4 ;

funkcija c($a, $b) (grįžti$a+ $b; }

//Naudojimas
aidas"prieš{ $_expr(1 + 2 )} paskelbti\n"; // išveda "pre 3 post"
aidas"prieš{ $_expr(qwe)} paskelbti\n"; // išveda "pre asd post"
aidas"prieš{ $_expr(c($a, $b)+ zxc* 2 )} paskelbti\n"; // išveda "prieš 17 įrašą"

// Bendroji sintaksė yra ($_expr(...))
?>

prieš 2 metus

Maniau, kad būtų naudinga pridėti šį komentarą, kad informacija bent jau atsirastų tinkamame PHP svetainės puslapyje.

Atminkite, kad jei ketinate naudoti eilutę su dvigubomis kabutėmis su asociatyviniu raktu, galite susidurti su klaida T_ENCAPSED_AND_WHITESPACE. Kai kurie mano, kad tai vienas iš mažiau akivaizdžių klaidų pranešimų.

Tokia išraiška kaip:

$ vaisius=masyvas(
"a"=> "obuolys",
"b"=> "bananas",
//ir kt
);

Spausdinti "Tai yra a$ vaisius[ "a"]; // T_ENCAPSED_AND_WHITESPACE
?>

tikrai subyrės į gabalus.

Galite tai išspręsti taip:

Posakiuose, kur reikalinga eilutė, konvertavimas įvyksta automatiškai."Tai yra a$ vaisius[ a] " ; // ištraukite raktą
Posakiuose, kur reikalinga eilutė, konvertavimas įvyksta automatiškai."Tai yra a${ vaisių[ "a"]} " ; // Sudėtinga sintaksė
Posakiuose, kur reikalinga eilutė, konvertavimas įvyksta automatiškai."Tai yra a{ $ vaisius[ "a"]} " ; // Sudėtingas sintaksės variantas
?>

Asmeniškai teikiu pirmenybę paskutiniam variantui, nes jis yra natūralesnis ir artimesnis tam, koks būtų posakis už eilutės ribų.

Neaišku (bent jau man), kodėl PHP klaidingai interpretuoja vieną išraiškos kabutę, bet aš įsivaizduoju, kad tai yra kažkas bendro su faktu, kad kabutės nėra reikšmių eilutės dalis – kai eilutė jau analizuojama, kabutės tiesiog trukdyti...?

prieš 2 metus

Abu turėtų veikti :(

klasėTestavimas{
viešas statinis$VAR= "statinis";
visuomenės const VAR ="konst";

Viešoji funkcija pasakykite Sveiki, Statiškas() {
aidas"labas:{ $tai:: $VAR} " ;
}

Viešoji funkcija pasakykite SveikiConst() {
aidas"labas:{ $tai::VAR)" ; //Išanalizavimo klaida: sintaksės klaida, netikėta ")", laukiama "["
}
}

$obj= naujasTestavimas();
$obj-> pasakykite Sveiki, Statiškas();
$obj-> pasakykite SveikiConst();

prieš 3 metus

Kažkas, ką patyriau, neabejotinai kažkam padės. . .
Mano redaktoriuje sintaksė paryškins HTML ir $commentą:

$html =<<<"EOD"
$komentuoti
apimantis kelias linijas,

Naudojant tai, visos spalvos yra vienodos:

$html =<<$komentuoti
apimantis kelias linijas,

todėl daug lengviau dirbti

prieš 11 metų

Kad nesusimąstytumėte, neskaitykite ankstesnių komentarų apie datas ;)

Kai abi eilutes galima konvertuoti į skaičius (teste ("$a" > "$b")), tada naudojami gauti skaičiai, kitu atveju FULL eilutės lyginamos po simbolius:

var_dump("1.22" > "01.23" ); //bool(false)
var_dump("1.22.00" > "01.23.00" ); //bool(tiesa)
var_dump("1-22-00" > "01-23-00" ); //bool(tiesa)
var_dump((plūduriuoti)"1.22.00" > (plūduriuoti)"01.23.00" ); //bool(false)
?>

PHP eilutės yra apsuptos viengubomis arba dvigubomis kabutėmis. Pagrindinis skirtumas yra tas, kad kintamąjį galite įdėti į dvigubas kabutes:

Dabar galime sugalvoti kitą problemos sprendimą iš pamokos Kintamieji PHP:

$titulas"; aidas"

Kaip PHP randa kintamąjį eilutėje?

Tai paprasta. Ar prisimenate, kokius simbolius galima naudoti kintamojo pavadinime? Tai yra skaičiai, raidės ir apatiniai brūkšniai _.

Taigi PHP vadina viską, kas yra tarp $ simbolio ir pirmojo draudžiamo simbolio.

Šiame kode PHP neteisingai nustatys kintamojo pavadinimą ir išmes klaidą:

Rezultatas naršyklėje:

Pastaba: neapibrėžtas kintamasis: Pricerub 3 eilutėje D:\OpenServer\domains\site\index.php

Kad PHP teisingai nustatytų kintamojo pavadinimą eilutėje, turite jį įdėti į riestinius skliaustus () :

Rezultatas naršyklėje:

1499 rubliai

Nėra aiškios nuomonės, kurios kabutės turėtų būti naudojamos paprastoms eilutėms, kuriose nieko nereikia pakeisti. Tačiau daugelis programuotojų nori naudoti pavienes kabutes.

Faktas yra tas, kad daugeliui žmonių dvigubos kabutės sukelia asociaciją „kažkas turi būti įterpta į šią eilutę“. Todėl įprastam tekstui rekomenduoju naudoti pavienes kabutes, o dvigubas kabutes tik tada, kai tekste reikia pakeisti kintamąjį. Pavyzdys:

Pabėgusios citatos

Jei eilutėje reikia įdėti kabutes, tai galite padaryti dviem būdais:

Antrame pavyzdyje pasvirasis brūkšnys \ išeina iš šios citatos, kad PHP traktuotų ją kaip eilutę.

Ką, jūsų nuomone, reikia padaryti, kad ekrane būtų rodomi tik pasvirieji brūkšniai? Juk tai išvengs baigiamosios citatos. Juokinga, bet reikia parašyti antrą pasvirąjį brūkšnį, kad išvengtumėte pirmojo:

Lentelės ir eilučių lūžiai dvigubose kabutėse

Pasvirasis brūkšnys dvigubose kabutėse leidžia pabėgti ne tik nuo kabučių ir jos pačios, bet ir kai kurių kitų simbolių. Populiariausi yra tabuliavimas (ilgas tarpas, kurį gaunate paspaudus TAB) ir eilutės lūžis. Jie atrodo taip:

Parašykite scenarijų, kuris:
1. Sukuria $type kintamąjį su reikšme Game.
2. Sukuria $name kintamąjį su reikšme "World of Warcraft" (su kabutėmis).
3. Rodo abu kintamuosius žymos viduje

. Tarp kintamųjų turi būti tarpas.

Tipo eilutės reikšmės yra teksto eilutės (sutrumpintai eilutės). Eilutė yra nulio ar daugiau simbolių seka. Simboliai apima raides, skaičius, skyrybos ženklus, specialiuosius simbolius ir tarpus.

Eilutę galima apibrėžti keturiais skirtingais būdais:

• dvigubos kabutės
• pavienės citatos
• heredoc sintaksė
• nowdoc sintaksė

Styga dvigubose kabutėse

Eilė dvigubose kabutėse:

Galite naudoti pabėgimo sekas eilutėse su dvigubomis kabutėmis. Valdymo seka— tai specialūs simboliai, skirti formatuoti teksto išvestį. PHP galimos šios pabėgimo sekos:

Pagrindinė eilučių su dvigubomis kabutėmis savybė yra galimybė tvarkyti kintamuosius eilutėse.

Dolerio ženklas: \$";

Dvigubose kabutėse pateiktose eilutėse gali būti viengubų kabučių simbolių:

Echo "Viena citata: "";

Eilė pavienėse kabutėse (apostrofai)

Eilė vienose kabutėse:

$str = "Eilutė"; echo "Viena didelė eilutė gali būti padalinta į kelias mažas eilutes, kad būtų lengviau skaityti.";

Skirtingai nei eilutės su dvigubomis kabutėmis ir heredoc sintaksė, kintamieji ir valdymo sekos (su viena išimtimi), įterptos į vieną kabutę, nėra apdorojamos. Tai reiškia, kad jie bus interpretuojami kaip įprasti eilutės simboliai:

$skaičius = 10; echo "Numeris: $num
Dolerio ženklas: \$";

Kad galėtumėte naudoti pavienes kabutes eilutėje, įtrauktoje į atskiras kabutes, turite jas pabėgti naudodami pasvirąjį brūkšnį (\"). Jei reikia parašyti patį pasvirąjį brūkšnį, turite jį nukopijuoti (\\):

Echo "Naudokite \"vienas\" kabutes viduje"; echo "Backslash: \\";

Vienose kabutėse esančiose eilutėse gali būti dvigubų kabučių simbolių:

Echo "Dviguba citata: "";

Heredoc sintaksė

Heredoc sintaksė yra alternatyvus būdas rašyti eilutes.

Eilutė, apibrėžta naudojant Heredoc sintaksę, veikia taip pat, kaip eilutė su dvigubomis kabutėmis. Skirtumas tarp Heredoc ir dvigubų kabučių eilutės yra tas, kad naudojant Heredoc nereikia vengti dvigubų kabučių.

Heredoc sintaksė prasideda trimis simboliais<<< , после которых должен быть указан произвольный идентификатор (назовём его открывающим). Идентификатор может быть указан как в двойных кавычках, так и без них. Iš karto po identifikatoriaus turi būti nauja eilutė, po identifikatoriaus neturi būti kitų simbolių, išskyrus naują eilutę, kitaip įvyks klaida. Toliau ateina pats eilutės turinys. Po eilutės turinio atskiroje eilutėje turi būti nurodytas uždarymo identifikatorius (tas pats kaip ir po<<<). Перед ним и после него не должно быть никаких пробелов или других символов, за исключением точки с запятой. Если это правило нарушено, то считается, что закрывающий идентификатор отсутствует и будет вызвана ошибка:

<<

Nowdoc sintaksė

Nowdoc sintaksė, kaip ir Heredoc, yra alternatyvus būdas rašyti eilutes.

Eilutė, apibrėžta naudojant Nowdoc sintaksę, veikia taip pat, kaip eilutė, įterpta į atskiras kabutes. Skirtumas tarp Nowdoc ir vienos kabutės eilutės yra tas, kad naudojant Nowdoc nereikia vengti pavienių kabučių.

Nowdoc sintaksė yra panaši į Heredoc, vienintelis skirtumas yra tas, kad atidarymo identifikatorius turi būti įdėtas į atskiras kabutes:

$skaičius = 10; aidas<<<"some_id" Число: $num some_id;

Kintamųjų tvarkymas eilutėse

Yra dviejų tipų sintaksės, skirtos kintamiesiems tvarkyti eilutėse: paprastas Ir sunku.

Paprasta sintaksė- tai tada, kai kintamojo pavadinimas nurodomas eilutėje toks, koks yra.

Kai vertėjas susiduria su dolerio ženklu, jis pradeda nuosekliai tikrinti, ar visi tolesni simboliai yra tinkami kintamojo pavadinimo simboliai. Taigi, norint sudaryti tinkamą kintamojo pavadinimą, jis fiksuoja kuo daugiau simbolių:

$str = "Pasaulis!"; echo "Sveiki $str";

Sudėtinga sintaksė- tai yra tada, kai kintamojo pavadinimas įterpiamas į riestinius skliaustus.

Kadangi, norėdamas apdoroti kintamąjį eilutėje, vertėjas užfiksuoja kuo daugiau simbolių, yra situacijų, kai vertėjas negali savarankiškai nustatyti, kur baigiasi kintamojo pavadinimas:

$sport1 = "valia"; $sport2 = "pėda"; echo "Man patinka $sport1ball ir $sport2ball";

Šiuo atveju norimas rezultatas nebus pasiektas, nes vertėjas $sport1 laikys neegzistuojančio kintamojo pavadinimo $sport1bol dalimi.

Kad aiškintojui aiškiai pasakytumėte, kur baigiasi kintamojo pavadinimas, turite įterpti kintamojo pavadinimą į skliaustus:

$sport1 = "valia"; $sport2 = "pėda"; echo "Man patinka ($sport1)bol ir ($sport2)bol.";

Dolerio ženklas gali būti dedamas prieš arba po garbanotosios petnešos:

$sport1 = "valia"; $sport2 = "pėda"; echo "Man patinka $(sport1)bol ir ($sport2)bol.";

Sujungimas

Sujungimas yra dviejų ar daugiau eilučių sujungimas į vieną didesnę eilutę. Sujungimas vyksta naudojant sujungimo operatorių - . (taškas). Kai sujungiama, kiekviena paskesnė eilutė pridedama prie ankstesnės pabaigos:

Bet kokio tipo reikšmė, sujungta su eilute, bus netiesiogiai konvertuojama į eilutę ir tada sujungiama:

"; echo "Skaičius: " . 1; ?>

Kokio tipo kabutes turėčiau naudoti eilutėms formatuoti – apostrofus ar klasikines dvigubas kabutes?

Pažvelkime į skirtumą tarp dvigubų ir pavienių kabučių PHP ir naudokite pavyzdžius, kad išsiaiškintumėte, kada kurią naudoti.

Kintamieji ir specialiųjų simbolių pabėgimo sekos, esančios eilutėse, pateiktose vienose kabutėse, neapdorojamos. Apostrofais apsuptas eilutes PHP interpretatorius apdoroja daug greičiau nei panašias eilutes, apsuptas dvigubomis kabutėmis.

Priežastis čia paprasta: PHP interpretatorius papildomai tikrina eilutes dvigubose kabutėse, ar nėra kintamųjų, o jei jie randami, vietoj kintamojo pavadinimo į eilutę įterpiama jo reikšmė. Tačiau eilutę, esančią apostrofais, interpretatorius suvokia kaip įprastą tekstą ir PHP šiose eilutėse neatlieka jokių transformacijų. Manau, aišku, kad eilučių apdorojimas vienose kabutėse bet kokiu atveju bus greitesnis.

Pirmiausia apibūdinkime, kaip apibrėžti eilutę, o tada patikrinkite, kiek greičiau bus apdorotos eilutės pavienėmis kabutėmis.

Paprasčiausias būdas apibrėžti eilutę yra įterpti ją į pavienes kabutes ("). Jei norite naudoti pavienes kabutes eilutėje su kabutėmis, prieš jas turi būti pasvirasis brūkšnys (\), t. y. paliktas. prieš vieną kabutę arba būti eilutės pabaigoje, ją reikia nukopijuoti.

Štai pavienių kabučių naudojimo pavyzdys:
// Išvestis: paprasta eilutė
aidas "Paprasta eilutė";
// Spaudiniai: Aš čia
aidas "Aš čia";
// Išvestis: nebus įterpta: \n nauja eilutė
echo "Tai neįterps:\nnauja eilutė";
// Išėjimai: $example kintamasis taip pat nebus pakeistas
echo "Kintamasis $example taip pat nebus pakeistas";

Jei eilutė yra įterpta į dvigubas kabutes ("), PHP atpažįsta daugiau specialiųjų simbolių pabėgimo sekų ir taip pat pakeičia kintamojo pavadinimą į eilutę, skirtą jo vertei. Lygiai taip pat kaip ir su pavienėmis kabutėmis, kad būtų naudojamos dvigubos kabutės eilutėje, esančioje dvigubas kabutes, prieš jas turi būti pasvirasis brūkšnys (\).
// Išvestis: paprasta eilutė
aidas "Paprasta eilutė";
Štai dvigubų kabučių naudojimo pavyzdys:
// Išėjimai: Įmonė "Snieguolė"
echo "Įmonė \"Snieguolė\"";
// Išvestis: bus sukurta nauja eilutė
echo "Tai bus perkelta į naują eilutę \n";
// Išvestis: kintamasis bus pakeistas
echo "Kintamasis $pavyzdys";

Taip pat turėtumėte atsiminti, kad seka „\n“ (nauja eilutė), „\r“ (karietos grąžinimas) skirta paprastam tekstui, o ne HTML. Taigi naršyklėje pokyčių nematysite (tik puslapio šaltinio kode).
Sužinokime, kiek pavienės kabutės yra greitesnės nei dvigubos kabutės. Matavimams parašysime trumpą testo scenarijų ir iš karto pažymėsime, kad jei išbandysite patys, rezultatai, priklausantys nuo Jūsų kompiuterio ar serverio aparatinės įrangos, skirsis.
// Grąžina laiko žymą ciklo pradžioje
$pradžia = mikrolaikas(tiesa);
// Sukurkite ciklą 1 milijonui iteracijų< 1000000; $i++) {
už ($i = 0; $i
}
$text = "Čia yra simbolių eilutė";
// Apskaičiuokite praleistą laiką

$laikas = (mikrolaikas(tiesa) - $pradžia);
Rezultatas: 0,09 sekundės.

Jei pavienes kabutes pakeisime dvigubomis kabutėmis:
$text = "Čia yra simbolių eilutė";
Rezultatas bus 0,10 sek.

Kaip matote, naudojant teksto eilutes, vykdymo laiko skirtumas yra labai mažas, netgi galima sakyti, kad jo visai nėra. Linksmybės prasideda, kai bandome sujungti eilutę ir kintamąjį.

$text = "Čia yra simbolių eilutė $i";

arba

Pavienės citatos

$tekstas = $i."Čia yra simbolių eilutė";

Rezultatas apytiksliai: 0,27 sekundės.

Skirtumas gana pastebimas. Sujungimas ir dvigubos kabutės aiškiai veikia našumą, kai į eilutę pridedami kintamieji.

Kai serveris apdoroja kodą, jis patikrina visą dvigubų kabučių turinį, ar nėra kintamųjų, konstantų ir kt. Tam reikia laiko. O serveris apdoroja tai, kas yra tarp pavienių kabučių, kaip paruoštą tekstą ir nesirūpina, kas ten yra. Skirtumas tarp viengubų ir dvigubų kabučių našumo yra labai mažas, tačiau jei kuriate labai apkrautą projektą, sutaupytos kelios milisekundės jau yra pergalė.:

Dvigubos kabutės

Ne paslaptis, kad PHP kabutės gali būti vienkartinės arba dvigubos. Išsiaiškinkime, kada tam tikri kabučių naudojimo būdai yra tinkamesni.

Paprasčiausias būdas apibrėžti eilutę yra įterpti tekstą į atskiras kabutes.

Dvigubose kabutėse esanti eilutė atpažįsta daugumą specialiųjų simbolių pabėgimo sekų.

Svarbiausias skirtumas yra tas, kad dvigubos kabutės tvarko kintamuosius.

Dvigubų kabučių naudojimo pavyzdžiai:

Sutelkime dėmesį į tai, kad eilutės su dvigubomis kabutėmis tvarko kintamuosius.

Kas nutinka, kai apdorojama eilutė? Vertėjas patikrinkite kiekvieną eilutę su dvigubomis kintamųjų kabutėmis, t.y. įvyksta priverstinis analizavimas, kuris užtrunka daugiau laiko. Taip, dažnai tai yra sekundės dalis, tačiau reikia suprasti patį faktą. Tai yra, jei palyginsite vienos eilutės apdorojimą su skirtingomis kabutėmis (žinoma, be kintamųjų), tada eilutė su pavienėmis kabutėmis tikrai bus apdorojama greičiau.

Skaičiavimai

ProfiPHP svetainėje radau įdomių skaičiavimų šia tema. Autorius parašė paprastą scenarijų, pagal kurį apskaičiavo eilučių apdorojimo laiką.