Koncept operatorskih zagrada. Operatorske zagrade u PHP-u
U prošlom postu pogledali smo sintaksu uslovnog izraza u PHP-u. U ovoj napomeni ćemo govoriti o zagradama operatera. Stalno ćete ih susresti. Ovo je osnovni koncept svakog programskog jezika.
Wikipedia će nam pomoći da odgovorimo na pitanje šta su operatorske zagrade:
Operatorske zagrade- zagrade ili naredbe koje definiraju blok naredbi u programskom jeziku, koji se percipira kao jedinstvena cjelina, kao jedna naredba.
IN Pascal jezik za označavanje operatorskih zagrada koristi se konstrukcija početi…. kraj. U jezicima sličnim C (što uključuje PHP), operatorske zagrade su opisane pomoću simbola {…} .
One. drugim riječima, nekoliko naredbi zatvorenih u operatorske zagrade se tretiraju kao 1 naredba.
U članku o uvjetima u PHP-u bio je primjer:
$b) ( echo "Varijabla A je veća od B"; ) else ( echo "Varijabla B je veća od A"; ) ?>
U ovom primjeru operatorske zagrade se koriste 2 puta. Oni postavljaju operatere
- echo“Varijabla A je veća od B”;
- echo“Varijabla B je veća od A”;
U ovom primjeru postoji samo 1 izjava zatvorena u zagrade, tako da je ekvivalentno pisanju ovako:
$b) echo "Varijabla A je veća od B"; else echo "Varijabla B je veća od A"; ?>
Sintaksa:
Ako (uslov) izraz 1; else izraz 2;
Recimo da želimo da prikažemo još jednu liniju na ekranu ako uslov nije ispunjen. Promijenimo i vrijednosti naših varijabli tako da sada $a bio > $b. Izmijenimo naš kod:
$b) echo "Varijabla A je veća od B."; else echo "Varijabla B je veća od A."; echo "Da..da A je zapravo manji od B."; ?>
Uradimo to... Šta vidimo na ekranu:
Varijabla A je veća od B. Da..da A je zapravo manja od B.
Ovde je negde greška. Kao što ste možda pretpostavili, cijela poenta je da pošto je naš uslov tačan (a > b), kod se izvršava:
Echo "Varijabla A je veća od B.";
U temi ostalo Imamo samo 1 izraz:
Echo "Varijabla B je veća od A.";
Sljedeći izraz će se izvršiti bez obzira na uvjet. Volim ovo:
$b) echo "Varijabla A je veća od B."; else echo "Varijabla B je veća od A."; echo "Da..da A je zapravo manji od B."; ?>
Sada koristimo operatorske zagrade i kombinujemo 2 izraza u grani ostalo:
$b) ( echo "Varijabla A je veća od B."; ) else ( echo "Varijabla B je veća od A."; echo "Da..da A je zapravo manja od B."; ) ?>
Kod je postao mnogo jasniji. Sad PHP razumije da ako uvjet ($a > $b) nije ispunjen, treba ispisati 2 reda. A ako je uslov tačan - samo jedan.
Moj veliki za tebe savjet– uvijek koristite operatorske zagrade, čak i ako ne trebate kombinirati nekoliko operatora u 1 blok. Činjenica je da:
- Na ovaj način je kod lakše čitati. Kratkim pogledom na šifru, vidimo njene pojedinačne blokove, a ne vinigret slova i brojeva.
- Često se moraju izvršiti promjene starog koda. Ako niste imali operatorske zagrade, a vi ste (kao u našem slučaju) dodali neki kod, onda će logika programa biti pogrešna. Možda to nećete ni primijetiti odmah.
Jednostavna sintaksa
Ako tumač naiđe na znak dolara ($), on uzima što je više moguće znakova kako bi formirao valjano ime varijable. Ako želite da navedete kraj imena, stavite ime varijable u vitičaste zagrade.
$beer = "Heineken" ;
echo "Okus piva je odličan" ; // radi, """ je nevažeći znak za ime varijable
echo "Popio je malo piva" ; // ne radi, "s" je važeći znak za ime varijable
echo "Popio je malo (piva)" ; // radi
echo "Popio je malo ($piva)" ; // radi
?>
Element niza ( niz) ili svojstvo objekta ( objekt). U indeksima niza postoji uglasta zagrada koja zatvara ( ] ) označava kraj definicije indeksa. Za svojstva objekta vrijede ista pravila kao i za jednostavne varijable, iako se ne mogu prevariti kao s varijablama.
// Ovi primjeri se posebno odnose na internu upotrebu nizova
// linije. Izvan nizova, uvijek priložite ključeve svojih stringova
// niz u navodnicima i ne koristi vanjske nizove (zagrade).
// Pokažimo sve greške
error_reporting(E_ALL);
$fruits = array("strawberry" => "crveno" , "banana" => "žuto");
// Radi, ali imajte na umu da izvan citiranog stringa radi drugačije
echo "Banana je voće.";
//Works
echo "Banana je ($fruits["banana"]).";
// Radi, ali PHP, kao što je opisano u nastavku, prvo traži
// konstantna banana.
echo "Banana je ($voće).";
// Ne radi, koristite vitičaste zagrade. Ovo će uzrokovati grešku u obradi.
echo "Banana je $fruits["banana"].";
// Works
echo "Banana je " . $fruits [ "banana" ] . "." ;
// Works
echo "Ovaj kvadrat je širok $square->width metara.";
// Ne radi. Pogledajte složenu sintaksu za rješenje.
echo "Ovaj kvadrat je širok $square->width00 centimetara.";
?>
Za složenije zadatke možete koristiti složenu sintaksu.
Složena (kovrdžava) sintaksa
Ova sintaksa se naziva složenom ne zato što je teško razumjeti, već zato što dozvoljava upotrebu složenih izraza.
U stvari, možete uključiti bilo koju vrijednost koja se nalazi u imenskom prostoru u red s ovom sintaksom. Jednostavno napišete izraz na isti način na koji biste to učinili izvan reda, a zatim ga zatvorite u ( i ). Pošto ne možete pobjeći od "(", ova sintaksa će biti prepoznata samo kada $ odmah slijedi (. (Koristite "(\$" ili "\($" za bijeg od "($"). Neki ilustrativni primjeri:
// Pokažimo sve greške
error_reporting(E_ALL);
$great = "fantastično" ;
// Ne radi, ispisat će se: Ovo je ( fantastično)
echo "Ovo je ($odlično)" ;
// Radi, printovi: Ovo je fantastično
echo "Ovo je ($odlično)" ;
echo "Ovo je $(odlično)" ;
// Works
echo "Ovaj kvadrat je ($square->width) širok 00 centimetara.";
// Works
echo "Radi: ($arr)";
// Ovo je nevažeće iz istog razloga zbog kojeg je $foo nevažeći izvana
// linije. Drugim riječima, i dalje će raditi,
// ali pošto PHP prvo traži konstantu foo, to će uzrokovati
// greška nivoa E_NOTICE (nedefinisana konstanta).
echo "Ovo nije u redu: ($arr)";
// Works. Kada koristite višedimenzionalne nizove, unutra
// linije uvijek koriste vitičaste zagrade
echo "Ovo radi: ($arr["foo"])";
// Works.
echo "Ovo radi: " . $arr [ "foo" ][ 3 ];
Echo "Možete čak i napisati ($obj->values->name)";
Echo "Ovo je vrijednost varijable pod nazivom $name: ($($name))";
?>
Znakovi u nizovima se mogu koristiti i modificirati specificiranjem njihovog pomaka od početka niza, počevši od nule, u vitičastim zagradama nakon niza. Evo nekoliko primjera:
// Dobivamo prvi znak niza
$str = "Ovo je test." ;
$prvi = $str (0);
// Dobivamo treći znak niza
$third = $str (2);
// Dobivamo posljednji znak niza
$str = "To je još uvijek test.";
$zadnji = $str (strlen ($str) - 1);
// Promjena posljednjeg znaka reda
$str = "pogledaj more";
$str ( strlen ($str ) - 1 ) = "self" ;
?>
Funkcije niza i operatori
String operatori
Različiti programski jezici koriste različite operatore konkatenacije nizova. Na primjer, Pascal koristi operator "+". Upotreba "+" operatora za spajanje stringova u PHP-u je netačna: ako stringovi sadrže brojeve, onda će se umesto spajanja stringova izvršiti operacija sabiranja dva broja.
PHP ima dva operatora koji izvode konkatenaciju.
Prvi je operator konkatenacije ("."), koji vraća konkatenaciju lijevog i desnog argumenata.
Drugi je operator dodjeljivanja sa konkatenacijom, koji dodaje desni argument lijevom.
Dajemo konkretan primjer:
$a = "Zdravo" ;
$b = $a. "Svijet!" ; // $b sadrži string "Hello World!" - Ovo je konkatenacija
$a = "Zdravo" ;
$a .= "Svijet!" ; // $a sadrži string "Hello World!" - Ovo je zadatak sa konkatenacijom
?>
Operatori poređenja nizova
Nije preporučljivo koristiti operatore poređenja == i != za poređenje nizova jer zahtijevaju konverziju tipa. primjer:
$x = 0; x - prazan niz y - prazan niz
$y=1;
if ($x == "" ) eho "
if ($y == "" ) eho "
// Izlazi:
// x je prazan niz
?>
Ova skripta nam govori da je $x prazan string. To je zbog činjenice da se prazan niz ("") prvo tretira kao 0, a tek onda kao "prazan". U PHP-u se operandi porede kao stringovi samo ako su oba stringova. Inače se upoređuju kao brojevi. U ovom slučaju, svaki niz koji PHP ne može da konvertuje u broj (uključujući prazan string) biće tretiran kao 0.
Primjeri poređenja nizova:
$x = "String" ; Niz X jednak je nizu Z Niz X jednak je nizu Y Niz X NIJE jednak nizu Z
$y = "String" ;
$ z = "Linija" ;
if ($x == $z) eho "
if ($x == $y) eho "
if ($x != $z) eho "
// Izlazi:
// String X je jednak nizu Y
?>
Da biste izbjegli zabunu i konverziju tipa, preporučuje se korištenje operatora ekvivalencije prilikom upoređivanja nizova. Operator ekvivalencije vam uvijek omogućava da ispravno uporedite nizove, jer uspoređuje vrijednosti i po vrijednosti i po vrsti:
$x = "String" ; Niz X jednak je nizu Z Niz X jednak je nizu Y Niz X NIJE jednak nizu Z
$y = "String" ;
$ z = "Linija" ;
if ($x == = $z) eho "
if ($x === $y) eho "
if ($ x !== $ z ) eho "
// Izlazi:
// String X je jednak nizu Y
// String X NIJE jednak nizu Z
?>
Pozdrav dragi programeri početnici. Nastavimo proučavati elemente koji čine.
U ovom članku ćemo naučiti šta su php operatori. Zapravo, neke od njih poznajemo gotovo od djetinjstva, ali ih znamo samo kao znakove (+, -, =, !, ?).
U php-u se svi oni zovu operatori, što je sasvim logično, budući da izvode određenu radnju, odnosno operaciju.
Možete čak reći da su svi znakovi za štampanje koji nisu slovo ili broj operatori u PHP-u. Ali to nije sve, jer postoje operatori koji se sastoje od slova.
Počnimo redom.
Aritmetički operatori
Aritmetički operatori se koriste za izvođenje operacija nad brojevima.
+ je operator sabiranja;
— — operator oduzimanja;
/ - operater divizije;
* — operator množenja;
% je operator za dobijanje ostatka tokom dijeljenja;
++ — operator za povećanje za jedan (inkrement);
— — — smanjenje za jednog operatera (dekrement)
Prilikom pisanja, razmak se obično stavlja ispred i iza operatora. Ovo se radi isključivo radi lakšeg čitanja koda, iako ovaj prostor ne utiče ni na šta, a možete i bez njega ako želite.
Složeni izrazi se sastavljaju prema pravilima prihvaćenim u aritmetici, odnosno množenje i dijeljenje imaju prednost nad sabiranjem i oduzimanjem, a kada su oba prisutna u izrazu, potonji se stavljaju u zagrade.
eho (6 + 7 ) * (7 + 8 ); // 195
?>
Prilikom izvođenja radnje dijeljenja cijelog broja cijelim brojem, u slučaju dobivanja ostatka, rezultat se automatski pretvara u realan broj (broj s pomičnim zarezom).
echo 8 / 3 ; //2.66666666666
?>
Broj prikazanih znakova za frakcijski broj, zavisi od vrijednosti postavljene u direktivi preciznosti koja se nalazi u datoteci php.ini. Obično je to 12 znakova ne računajući tačku.
Operator % se obično koristi za određivanje da li je jedan broj djeljiv drugim bez ostatka ili ne.
echo 53328 % 4 ; //0
?>
Pozivaju se operacije s aritmetičkim operatorima, s izuzetkom inkrementa i dekrementa binarni, budući da uključuju dva operanda (pojam + član, dividenda/djelitelj, itd.)
Pozivaju se akcije povećanja i smanjenja unarno, budući da uključuju jedan operand. Ima li još uslovni rad, koji uključuje tri operanda.
Operatori povećanja (++) i dekrementa (- -) primjenjuju se samo na varijable.
Tip varijable cijeli broj (cijeli brojevi)
$sljedeći = 3 ;
echo +$next; // 4
?>
String varijabilnog tipa
$next = "abc";
echo $next; // abd
?>
Umjesto slova "c" ispisuje se slovo "d" jer je ono sljedeće u abecedi i vrijednost varijable smo povećali za jedan.
Primeri pokazuju akcije sa povećanjem, a na isti način možete izvesti akcije sa smanjenjem.
Bitovi operatori
Bitovi operatori su dizajnirani za rad sa binarnim podacima. Ako neko nema pojma šta je, objasniću. Binarni brojevi su brojevi poput 1001000011100000111000.
Budući da se takvi podaci gotovo nikada ne koriste u izradi web stranica, nećemo se detaljnije zadržavati na njima. Ja ću vam samo pokazati kako oni izgledaju, tako da kada naiđete na takve simbole možete zamisliti s čime imate posla.
& - bitna veza I (i);
~ — bitna negacija (ne);
| — bitna unija OR (ili);
^ — bitsko OR (xor);
<<
— сдвиг влево битового значения операнда;
>> — pomjeriti udesno vrijednost bita operanda;
Vrlo je vjerovatno da ćete naići na ove operatore, budući da se binarni podaci naširoko koriste u razvoju programa za kompjutersku grafiku. Ali da bi ih proučili, ako nekome zatreba, moraće da pohađaju poseban kurs na drugom izvoru.
Operatori poređenja
Operatori poređenja su logički operatori i koriste se za poređenje varijabli. Nizovi i objekti se ne mogu porediti pomoću njih.
> - operator veći od;
=> - operator veće ili jednako;
<
— оператор меньше;
<=
— оператор меньше или равно;
== — operator jednakosti;
!= — operator nejednakosti;
=== — operator ekvivalencije (vrijednost i tip varijable su jednaki);
!== — operator neekvivalencije;
Kao rezultat poređenja, na ekranu se prikazuje ili jedan, što odgovara true (true), ili prazan niz, koji odgovara false (false).
eho 1 > 0 ; // 1
eho 1<
0
;
// пустая строка
eho 1 => 0 ; // 1
eho 1 == 1 ; // 1
?>
Dakle, sami po sebi, operatori poređenja se gotovo nikada ne koriste. Njihova glavna svrha je da rade u sprezi sa if naredbom.
Uslovne izjave if, else, elseif.
Uslovni operatori su tako nazvani jer su dizajnirani da testiraju određeni uslov, u zavisnosti od toga koja se određena radnja izvodi.
Naredba if uzima logičku varijablu ili izraz kao argument. Ako je uslov tačan, prikazuje se rezultat, ako nije tačan, prikazuje se prazan red.
ako ($sljedeći< $nexT)
{
eho "Šanse za padavine"; // Izlaz Moguće padavine
}
?>
$next = "Vlažnost vazduha 80%";
$nexT = "Vlažnost vazduha 90%";
if ($next > $nexT)
{
eho "Šanse za padavine"; // Ispis praznog reda
}
?>
Ako program treba specificirati dvije akcije, od kojih će se jedna izvršiti ako je vrijednost istinita, a druga ako je vrijednost lažna, tada se zajedno s if naredbom koristi naredba else
$next = "Vlažnost vazduha 80%";
$nexT = "Vlažnost vazduha 90%";
if ($next > $nexT)
{
eho "Šanse za padavine";
}
ostalo
{
eho "Ne očekuju se padavine";
}
?>
U tom slučaju će se prikazati “Padavine se ne očekuju”, a ako u izrazu promijenite znak “Više” u “Manje”, ispisat će se “Padavine su moguće”. Ovo je način na koji uvjetni izrazi provjeravaju uvjet i prema njemu daju ispravan rezultat.
Vrlo često postoji potreba da se postavi više od dva uslova, a zatim se, da bi se oni uzastopno proveravali, koristi operator elseif.
if ($next > $nexT)
{
eho "vidim";
}
elseif ($next<= $nexT)
{
eho "Snijeg";
}
elseif ($next >= $nexT)
{
eho "Kiša";
}
elseif ($next == $nexT)
{
eho "Suša";
}
ostalo
{
eho "Šanse za padavine";
}
?>
Ovaj program će ispisati "Snijeg". Ako nijedan od uslova ne odgovara, prikazaće se „Šanse za padavine“.
Naredba if može sadržavati onoliko blokova elseif koliko želite, ali samo jedan else izraz.
Dozvoljeno Alternativna opcija unosi - bez kovrčave zagrade. U ovom slučaju, redovi if, else, elseif naredbi završavaju dvotočkom, a cijela konstrukcija završava ključnom riječi (operator) endif.
$next = "Vlažnost vazduha 50%";
$nexT = "Vlažnost vazduha 60%";
ako ($sljedeći<= $nexT):
eho "Snijeg";
elseif ($next >= $nexT):
eho "Kiša";
elseif ($next == $nexT):
eho "Suša";
ostalo:
eho "Šanse za padavine";
endif ;
?>
Logički operatori
Logički operatori su slični operatorima u bitovima. Razlika između njih je u tome što prvi rade s logičkim varijablama, a drugi s brojevima.
Logički operatori se koriste u slučajevima kada je potrebno kombinirati nekoliko uvjeta, što će smanjiti broj if naredbi, što zauzvrat smanjuje vjerovatnoću grešaka u kodu.
&& - spojni veznik I;
i - takođe I, ali sa nižim prioritetom;
|| - razdvojni veznik ILI;
ili - takođe ILI, ali sa nižim prioritetom;
xor - ekskluzivno OR;
! - poricanje;
Niži prioritet znači da ako su prisutna oba operatora, prvi se izvršava onaj s višim prioritetom.
U budućnosti ćemo se fokusirati na primjere složenijih skripti logički operatori više detalja.
Operator dodjele
Operator dodjeljivanja = dodjeljuje vrijednost desnog operanda lijevom operandu.
$next = "Zdravo"
echo "Zdravo" // Zdravo
?>
Operator dot
Operator točka odvaja cjelobrojni dio broja od razlomka i kombinuje nekoliko nizova i broj u jedan cijeli niz.
$sljedeći = 22 ;
echo "Danas nakon" .$next. "mraz se očekuje"; // Danas se nakon 22 očekuje mraz
?>
Operator zagrade
Kao iu matematici, operator zagrade daje prioritet radnji koja je u njima.
Prvo se izvršavaju podaci navedeni u zagradama, a zatim svi ostali.
Operator vitičastih zagrada
Postoje tri načina, ili čak stilova, postavljanja vitičastih zagrada u PHP-u.
1. BSD stil - zagrade su poravnate lijevo.
ako ($sljedeći)
{
}
2. GNU stil - zagrade su poravnate uvučeno od lijevog ruba
ako ($sljedeći)
{
echo “Zdravo dragi programeri početnici”;
}
3. K&R stil - otvara se zagrada na liniji operatera
if ($sljedeći)(
echo “Zdravo dragi programeri početnici”;
}
Od samog početka morate odabrati jedan od stilova iu budućnosti, kada pišete skripte, koristite samo njega. Štaviše, uopšte nije važno koji stil preferirate. Važno je da bude ujednačen kroz program.
Mislim da je to dovoljno za sada. U principu, ne samo znakovi, već i funkcije i drugi elementi mogu biti operatori, tako da ih je vrlo teško sve nabrojati i nema smisla.
Dovoljno je imati predstavu o osnovnim osnovama. A ostalo ćemo analizirati na praktičnim primjerima.
Irac luta aerodromom Šeremetjevo u suzama. Jedan od zaposlenih odlučio je saosjećati:
— Nedostaje li ti domovina?
- Ne sve. Upravo sam izgubio sav svoj prtljag
- Kako se ovo moglo dogoditi?
- Ne razumem sebe. Izgleda da sam ispravno utaknuo utikač
Komentar: U PHP 7.0.0 na 64-bitnim platformama ne postoje dostižna ograničenja dužine linije na 32-bitnim sistemima, au ranijim verzijama PHP-a linije ne mogu biti veće od 2 GB (2147483647 bajtova).
Sintaksa
Niz se može definirati sa četiri Različiti putevi:
- jednostruki navodnici
- dvostruki navodnici
- nowdoc sintaksa (od PHP 5.3.0)
Jednostruki navodnici
Najjednostavniji način definirati niz znači staviti ga u jednostruke navodnike (znak " ).
Da biste koristili jedan navodnik unutar niza, izmaknite ga obrnutom kosom crtom ( \ ). Ako trebate napisati samu obrnutu kosu crtu, duplirajte je ( \\ ). Sve druge upotrebe obrnute kose crte će se tumačiti kao normalni znakovi: to znači da ako pokušate koristiti druge izlazne sekvence kao što je \r ili \n, oni će biti ispisani takvi kakvi jesu umjesto bilo kakvog posebnog ponašanja.
echo "ovo je jednostavan niz";
echo „Možete i umetnuti u redove
karakter za novi red ovako,
ovo je u redu";
// Izlazi: Arnold je jednom rekao: "Vratit ću se"
echo "Jednog dana Arnold je rekao: 'Vratiću se.';
Echo "Jeste li izbrisali C:\\*.*?";
// Izlazi: Jeste li izbrisali C:\*.*?
echo "Jeste li izbrisali C:\*.*?" ;
// Izlazi: Ovo neće biti prošireno: \n novi red
echo "Ovo neće biti prošireno: \n novi red";
// Izlazi: $expand i $either varijable nisu proširene
echo "$expand i $either varijable nisu proširene";
?>
Dvostruki navodnici
Ako je niz stavljen u dvostruke navodnike ("), PHP prepoznaje sljedeće escape sekvence posebnih znakova:
| Subsequence | Značenje |
|---|---|
| \n | novi red (LF ili 0x0A (10) u ASCII) |
| \r | povratak na nosivu (CR ili 0x0D (13) u ASCII) |
| \t | horizontalna kartica (HT ili 0x09 (9) u ASCII) |
| \v | vertikalna kartica (VT ili 0x0B (11) u ASCII) (od PHP 5.2.5) |
| \e | escape znak (ESC ili 0x1B (27) u ASCII) (od PHP 5.4.4) |
| \f | feed stranice (FF ili 0x0C(12) u ASCII) (od PHP 5.2.5) |
| \\ | obrnuta kosa crta |
| \$ | znak dolara |
| \" | dvostruki citat |
| \{1,3} | niz znakova koji odgovara regularnom izrazu oktalnog znaka koji se tiho prelijeva da bi se uklopio u bajt (tj. "\400" === "\000") |
| \x(1,2) | niz znakova koji odgovara regularnom izrazu znaka u heksadecimalnom zapisu |
| \u(+) | niz znakova koji odgovara regularnom izrazu Unicode karaktera koji se preslikava na niz u UTF-8 reprezentaciji (dodato u PHP 7.0.0) |
Kao i kod stringa zatvorenog u jednostruke navodnike, izbjegavanje bilo kojeg znaka će također dovesti do samog izlaznog znaka. Prije PHP 5.1.1, obrnuta kosa crta \($var) nije objavljeno.
Heredoc
Treći način definiranja stringova je korištenje heredoc sintakse: <<< . Nakon ovog operatora, morate navesti identifikator, a zatim prijelaz na red. Nakon toga dolazi sama linija, a zatim isti identifikator, koji zatvara umetanje.
Linija mora početi sa završnim identifikatorom, tj. mora se pojaviti u prvoj koloni reda. Dodatno, identifikator mora slijediti ista pravila imenovanja kao i sve druge oznake u PHP-u: sadržavati samo alfanumeričke znakove i donju crtu i ne smije početi brojem (donje crte su dozvoljene).
Pažnja
Vrlo je važno napomenuti da završni red identifikatora ne smije sadržavati nikakve druge znakove osim točke i zareze ( ; ). To znači da je id ne treba biti uvučen i da ne može biti nikakvih razmaka ili tabulatora prije ili poslije tačke i zareza. Također je važno razumjeti da prvi znak prije završnog identifikatora mora biti znak za novi red kako je definirao vaš operativni sistem. Na primjer, na UNIX sistemima, uključujući macOS, ovo je \n. Novi red također mora početi odmah nakon završnog identifikatora.
Ako je ovo pravilo prekršeno i identifikator zatvaranja nije "čist", smatra se da nedostaje i PHP će nastaviti da ga traži dalje. Ako se u ovom slučaju nikada ne pronađe ispravan identifikator zatvaranja, to će uzrokovati grešku raščlanjivanja s brojem reda na kraju skripte.
Primjer #1 Primjer netačne sintakse
klasa foo(
javni $bar =<<
EOT;
// uvlačenje ispred identifikatora zatvaranja nije dozvoljeno
}
?>
Primjer #2 Primjer ispravne sintakse
klasa foo(
javni $bar =<<
EOT;
}
?>
Heredoc se ne može koristiti za inicijalizaciju polja klase. Počevši od PHP 5.3, ovo ograničenje se odnosi samo na heredocs koji sadrže varijable.
Heredoc tekst se ponaša na isti način kao string u dvostrukim navodnicima, a da ih nema. To znači da ne morate izbjegavati navodnike u heredoc, ali i dalje možete koristiti gornje izlazne sekvence. Varijable se obrađuju, ali morate biti oprezni kada koristite složene varijable unutar heredoc-a kao i kada radite sa stringovima.
Primjer #3 Heredoc primjer definicije stringa
$str =<<
prostiru se na nekoliko redova,
koristeći heredoc sintaksu.
EOD;
Class foo
{
var $foo ;
var $bar ;
Function__construct()
{
$this -> foo = "Foo" ;
$this ->
}
}
$foo = novi foo();
$name = "Ime" ;
echo<<
Sad zaključujem( $foo -> bar [ 1 ]) .
Ovo bi trebalo dati veliko slovo "A": \x41
EOT;
?>
Moje ime je "Ime". Ukucam Foo. Sada, ispisujem Bar2. Ovo bi trebalo proizvesti veliko slovo "A": A
Također je moguće koristiti heredoc sintaksu za prosljeđivanje podataka kroz argumente funkcije:
Od verzije 5.3.0, postalo je moguće inicijalizirati statičke varijable i svojstva/konstante klase koristeći heredoc sintaksu:
Primjer #5 Korišćenje heredoc za inicijalizaciju statičkih varijabli
// Statičke varijable
funkcija foo()
{
statički $bar =<<
LABEL;
}
// Svojstva konstante/klase
class foo
{
const BAR =<<
FOOBAR;
Javni $baz =<<
FOOBAR;
}
?>
Od PHP 5.3.0, Heredoc identifikator možete okružiti i dvostrukim navodnicima:
Nowdoc
Nowdoc je isti za stringove sa jednostrukim navodnicima kao heredoc za nizove sa dvostrukim navodnicima. Nowdoc je sličan heredocu, ali unutar njega ne rade se zamjene. Ovaj dizajn je idealan za ugrađivanje PHP koda ili drugih velikih blokova teksta bez potrebe za izbjegavanjem. Po ovome je malo sličan SGML konstrukciji deklarisanjem bloka teksta koji nije namijenjen za obradu.
Nowdoc je označen istim nizom <<< , koji se koristi u heredoc, ali je sljedeći identifikator zatvoren u jednostrukim navodnicima, na primjer, <<<"EOT" . Svi uvjeti koji se primjenjuju na identifikatore heredoc također se primjenjuju na nowdoc, posebno oni koji se primjenjuju na identifikator zatvaranja.
Primjer #7 Primjer korištenja nowdoc
echo<<<"EOD"
Primjer teksta,
obuhvata nekoliko linija
koristeći sintaksu nowdoc. Obrnute kose crte se uvijek tretiraju doslovno,
na primjer, \\ i \".
EOD;
Rezultat pokretanja ovog primjera:
Primjer teksta koji se proteže u više redova koristeći sintaksu nowdoc. Obrnute kose crte se uvijek tretiraju doslovno, kao što su \\ i \".
Primjer #8 Nowdoc primjer navođenja stringova sa varijablama
/* Složeniji primjer sa varijablama. */
class foo
{
public $foo ;
javni $bar ;
Function__construct()
{
$this -> foo = "Foo" ;
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}
$foo = novi foo();
$name = "Ime" ;
echo<<<"EOT"
Moje ime je "$name". Štampam $foo->foo.
Sada štampam ($foo->bar).
Ovo ne bi trebalo da daje veliko "A": \x41
EOT;
?>
Rezultat pokretanja ovog primjera:
Moje ime je "$name". Štampam $foo->foo. Sada štampam ($foo->bar). Ovo ne bi trebalo da daje veliko "A": \x41
Primjer #9 Primjer korištenja statičkih podataka
klasa foo(
javni $bar =<<<"EOT"
bar
EOT;
}
?>
Komentar:
Nowdoc podrška je dodana u PHP 5.3.0.
Rukovanje varijablama
Ako je niz naveden u dvostrukim navodnicima ili koristeći heredoc, varijable unutar njega se obrađuju.
Postoje dvije vrste sintakse: jednostavna i složena. Jednostavna sintaksa je lakša i praktičnija. Omogućava obradu varijable, vrijednosti niza ( niz) ili svojstva objekta ( objekt) uz minimum napora.
Složena sintaksa se može prepoznati po vitičastim zagradama koje okružuju izraz.
Jednostavna sintaksa
Ako prevodilac naiđe na znak dolara ( $ ), hvata što je više moguće znakova kako bi formirao ispravno ime varijable. Ako želite da navedete kraj imena, stavite ime varijable u vitičaste zagrade.
$juice = "jabuka" ;
echo "Popio je sok od $juice." . PHP_EOL ;
// Netočno. "s" je važeći znak za ime varijable, ali varijabla se zove $juice.
echo "Popio je sok od $sokova." ;
// Ispravno. Kraj imena varijable je striktno označen uglastim zagradama:
echo "Popio je sok napravljen od $( soka) s." ;
?>
Rezultat pokretanja ovog primjera:
Popio je sok od jabuke. Popio je sok od . Popio je sok od jabuke.
Element niza ( niz) ili svojstvo objekta ( objekt). U indeksima niza postoji uglasta zagrada koja zatvara ( ] ) označava kraj definicije indeksa. Za svojstva objekta vrijede ista pravila kao i za jednostavne varijable.
Primjer #10 Jednostavan primjer sintakse
define ("KOOLAID" , "koolaid1" );
$juices = array("apple" , "orange" , "koolaid1" => "purple");
echo "Popio je malo $juices [ 0 ] soka." . PHP_EOL ;
echo "Popio je malo $juices [ 1 ] soka." . PHP_EOL ;
echo "Popio je malo $juices [ koolaid1 ] sok." . PHP_EOL ;
klasni ljudi (
public $john = "John Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;
Public $smith = "Smith" ;
}
$ljudi = novi ljudi();
echo "$people -> John je popio malo $juices [ 0 ] soka." . PHP_EOL ;
echo " $people -> john zatim pozdravio $people -> jane ." . PHP_EOL ;
echo "$people -> John "s žena je pozdravila $people -> Robert." . PHP_EOL;
echo " $ljudi -> Robert je pozdravio dva $ljudi -> smiths ." ; // Neće raditi
?>
Rezultat pokretanja ovog primjera:
Popio je sok od jabuke. Popio je sok od narandže. Popio je ljubičasti sok. John Smith je popio sok od jabuke. John Smith je zatim pozdravio Jane Smith. Roberta Paulsena pozdravila je supruga Johna Smitha.
PHP 7.1.0 je dodao podršku negativan numerički indeksi.
Primjer #11 Negativni numerički indeksi
$string = "string" ;
echo "Znak na indeksu -2 je jednak$string [- 2 ] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
echo "Promjena znaka na poziciji -3 u 'o' proizvodi sljedeći red:$string." , PHP_EOL;
?>
Rezultat pokretanja ovog primjera:
Znak sa indeksom -2 je jednak n. Promjena karaktera na poziciji -3 u "o" daje sljedeći red: jak
Za sve složenije, koristite složenu sintaksu.
Složena (kovrdžava) sintaksa
Naziva se složenim ne zato što ga je teško razumjeti, već zato što dozvoljava upotrebu složenih izraza.
Bilo koja skalarna varijabla, element niza ili svojstvo objekta mapirano u string može biti predstavljeno u nizu koristeći ovu sintaksu. Samo napišite izraz na isti način na koji biste to učinili izvan reda, a zatim ga umotajte { I } . Zbog { ne može se izbjeći, ova sintaksa će biti prepoznata samo kada $ sledi direktno { . Koristi {\$ isprintati {$ . Nekoliko ilustrativnih primjera:
// Prikaži sve greške
error_reporting(E_ALL);
$great = "odlično" ;
// Ne radi, izlazi: Ovo je (odlično)
echo "Ovo je ($odlično)" ;
// Radi, izlazi: Ovo je sjajno
echo "Ovo je ($odlično)" ;
// Works
echo „Ovaj trg je širok( $square -> width ) 00 centimetara." ;
// Radi, citirane ključne riječi rade samo sa sintaksom vitičastih zagrada
echo "Ovo radi: ( $arr [ "ključ" ]) " ;
// Works
echo "Ovo radi: ( $arr [ 4 ][ 3 ]) " ;
// Ovo je nevažeće iz istog razloga kao i $foo izvana
// linije. Drugim riječima, i dalje će raditi,
// ali pošto PHP prvo traži konstantu foo, to će uzrokovati
// greška nivoa E_NOTICE (nedefinisana konstanta).
echo „Nije u redu:( $arr [ foo ][ 3 ]) " ;
// Works. Kada se interno koriste višedimenzionalni nizovi
// linije uvijek koriste vitičaste zagrade
echo "Ovo radi: ( $arr [ "foo" ][ 3 ]) " ;
// Works.
echo "Ovo radi: " . $arr [ "foo" ][ 3 ];
echo "I ovo radi:( $obj -> vrijednosti [ 3 ]-> ime ) " ;
echo „Ovo je vrijednost imenovane varijable$name : ($( $name)) " ;
echo "Ovo je vrijednost imena varijable koju getName() vraća:($( getName ())) " ;
echo "Ovo je vrijednost varijable po imenu koju \$object->getName() vraća:($( $object -> getName ())) " ;
// Ne radi, izlazi: Ovo je ono što getName() vraća: (getName())
echo "Ovo je ono što getName() vraća: (getName())";
?>
Također je moguće pristupiti svojstvima objekta unutar stringova koristeći ovu sintaksu.
klasa foo(
var $bar = "Ja sam bar." ;
}
$foo = novi foo();
$bar = "bar" ;
$baz = array("foo" , "bar" , "baz" , "quux");
echo " ( $foo -> $bar ) \n" ;
echo " ( $foo ->( $baz [ 1 ])) \n" ;
?>
Rezultat pokretanja ovog primjera:
Ja sam bar. Ja sam bar.
Komentar:
Funkcije, pozivi metoda, statičke varijable klase i konstante klase rade interno {$} , počevši od PHP 5. Međutim, dostavljena vrijednost će se tretirati kao ime varijable u istom kontekstu kao i red u kojem je definirana. Korištenje pojedinačnih vitičastih zagrada ( {} ) neće raditi za pristup vrijednostima funkcija, metoda, konstanti klase ili statičkih varijabli klase.
// Prikaži sve greške
error_reporting(E_ALL);
klasa piva (
const softdrink = "rootbeer" ;
public static $ale = "ipa" ;
}
$rootbeer = "A & W" ;
$ipa = "Alexander Keith\"s" ;
// Ovo radi, izlazi: Želio bih A & W
echo "Želim ($( pivo :: bezalkoholno piće)) \n" ;
// I ovo radi, izlazi: Volio bih Alexander Keitha
echo "Želio bih ($( pivo :: $ale )) \n" ;
?>
Pristup i promjena karaktera u nizu
Znakovi u nizovima se mogu koristiti i modificirati specificiranjem njihovog pomaka od početka stringa, počevši od nule, u uglastim zagradama nakon niza, na primjer, $str. Zamislite string za ovu svrhu kao niz znakova. Ako trebate dobiti ili zamijeniti više od 1 znaka, možete koristiti funkcije substr() I substr_replace().
Komentar: Od PHP 7.1.0, podržane su negativne vrijednosti pomaka. Oni određuju pomak od kraja reda. Prethodno negativni pomaci uzrokovali su grešku nivoa E_NOTICE na čitanje (vraćanje praznog niza) ili E_UPOZORENJE prilikom pisanja (ostavljajući red nepromijenjen).
Komentar: Znaku u nizu se također može pristupiti pomoću vitičastih zagrada, na primjer $str(42) .
Pažnja
Pokušaj pisanja u pomak izvan granica linije će dopuniti string razmacima do tog pomaka. Necjelobrojni tipovi će se pretvoriti u cjelobrojne tipove. Pogrešan tip pomaka će uzrokovati grešku nivoa E_UPOZORENJE. Koristi se samo prvi znak dodijeljenog niza. Od PHP 7.1.0, dodeljivanje praznog niza će izazvati fatalnu grešku. Ranije je u ovom slučaju dodijeljen nulti bajt (NULL).
Pažnja
Stringovi u PHP-u su interni nizovi bajtova. Kao rezultat toga, pristupanje nizu ili izmjena niza na pomaku nije sigurno za višebajtno kodiranje, i treba ga raditi samo sa nizovima u jednobajtnim kodovima, kao što je ISO-8859-1.
Komentar: Budući da PHP 7.1.0, korištenje praznog indeksa ranije uzrokuje fatalnu grešku, u ovom slučaju, niz je konvertovan u niz bez upozorenja.
Primjer #12 Neki primjeri nizova
// Dobivamo prvi znak niza
$str = "Ovo je test." ;
$prvi = $str [0];
// Dobivamo treći znak niza
$third = $str [2];
// Dobivamo posljednji znak niza
$str = "Ovo je još uvijek test." ;
$last = $str [strlen ($str) - 1];
// Promjena posljednjeg znaka reda
$str = "Pogledajte more" ;
$str [ strlen ($str )- 1 ] = "e" ;
?>
Od PHP 5.4, pomak u nizu mora biti specificiran ili kao cijeli broj ili kao niz koji sadrži cifre, inače će biti izdato upozorenje. Prethodno pomak dat nizom poput "foo", bez upozorenja je pretvoren u 0 .
Primjer #13 Razlike između PHP-a 5.3 i PHP-a 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" ]));
?>
Rezultat pokretanja ovog primjera u PHP 5.3:
string(1) "b" bool(true) string(1) "b" bool(true) string(1) "a" bool(true) string(1) "b" bool(true)
Rezultat pokretanja ovog primjera u PHP 5.4:
string(1) "b" bool(true) Upozorenje: Ilegalni pomak niza "1.0" u /tmp/t.php na liniji 7 string(1) "b" bool(false) Upozorenje: Nedozvoljen pomak niza "x" u / tmp/t.php na liniji 9 string(1) "a" bool(false) string(1) "b" bool(false)
Komentar:
Pokušaj pristupa varijablama drugih tipova (isključujući nizove ili objekte koji implementiraju određena sučelja) koristeći ili {} ćutke će se vratiti NULL.
Komentar:
PHP 5.5 je dodao podršku za pristup znakovima u literalima niza koristeći sintaksu ili {} .
Postoje mnoge korisne funkcije za modificiranje nizova.
Osnovne funkcije su opisane u odjeljku o funkcijama stringova, a za napredno pretraživanje i zamjenu, funkcije regularnog izraza kompatibilne s Perl-om.
Pretvori u niz
Vrijednost se može pretvoriti u string pomoću cast (niz), ili funkcije strval(). U izrazima u kojima je potreban niz, konverzija se događa automatski. Ovo se dešava kada koristite funkcije echo ili print, ili kada se vrijednost varijable uporedi sa nizom. Čitanje odjeljaka Tipovi i Tipovi u priručniku učinit će sljedeće jasnije. vidi takođe settype().
Nizovi se uvijek pretvaraju u string "niz", tako da ne možete prikazati sadržaj niza ( niz), koristeći echo ili print da vidite šta sadrži. Da vidite jedan element, koristite nešto poput echo $arr["foo"]. U nastavku pogledajte savjete o tome kako prikazati/pogledati sav sadržaj.
Za pretvaranje varijable tipa "Objekat" u tipu string Koristi se magična metoda __toString.
Značenje NULL se uvijek pretvara u prazan niz.
Kao što vidite gore, direktno pretvaranje nizova, objekata ili resursa u niz ne daje nikakve korisne informacije o samim vrijednostima osim njihovih tipova. Bolji način za izlaz vrijednosti za otklanjanje grešaka je korištenje funkcija print_r() I var_dump().
Većina vrijednosti u PHP-u može se pretvoriti u string za trajno skladištenje. Ova metoda se naziva serijalizacija i može se izvesti pomoću funkcije serialize().
Pretvaranje nizova u brojeve
Ako je niz prepoznat kao numerička vrijednost, rezultirajuća vrijednost i tip se određuju na sljedeći način.
Ako niz ne sadrži nijedan od znakova ".", "e" ili "E", a vrijednost broja spada u raspon cijelih brojeva (definiranih PHP_INT_MAX), niz će biti prepoznat kao cijeli broj ( cijeli broj). U svim ostalim slučajevima smatra se brojem s pomičnim zarezom ( float).
Vrijednost je određena početkom niza. Ako linija počinje važećom numeričkom vrijednošću, ta vrijednost će se koristiti. Inače će vrijednost biti 0 (nula). Važeća brojčana vrijednost je jedna ili više cifara (koje mogu sadržavati decimalni zarez), opcionalno prethodi znak nakon kojeg slijedi opcijski eksponent. Eksponent je "e" ili "E" iza kojeg slijedi jedna ili više cifara.
$foo = 1 + "10.5" ; // $foo je float (11.5)
$foo = 1 + "-1.3e3" ; // $foo je float (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo je cijeli broj (1)
$foo = 1 + "bob3" ; // $foo je cijeli broj (1)
$foo = 1 + "10 malih svinja" ; // $foo je cijeli broj (11)
$foo = 4 + "10.2 Mala praseta" ; // $foo je float (14.2)
$foo = "10.0 svinja " + 1 ; // $foo je float (11)
$foo = "10.0 svinja " + 1.0 ; // $foo je float (11)
?>
Za više informacija o ovoj konverziji, pogledajte odjeljak strtod(3) u Unix dokumentaciji.
Ako želite da testirate bilo koji od primjera u ovom odjeljku, kopirajte ga i zalijepite i sljedeći red da vidite šta se događa:
echo "\$foo== $foo ; upišite: " . gettype ($foo) . "
\n" ;
?>
Ne očekujte da ćete dobiti kod znaka pretvarajući ga u cijeli broj (kao što se radi, na primjer, u C). Za pretvaranje znakova u njihove ASCII kodove i natrag, koristite funkcije ord() I chr().
Detalji implementacije tipa niza
prije 7 godina
U dokumentaciji se ne spominje, ali se završna tačka-zarez na kraju heredoc-a zapravo tumači kao prava tačka-zarez, i kao takva ponekad dovodi do sintaksičkih grešaka.
$foo =<<
END;
?>
ovo ne znači:
foo (<<
END;
);
// sintaksička greška, neočekivano ";"
?>
Bez tačke sa zarezom, radi dobro:
foo (<<
KRAJ
);
?>
prije 3 godine
Možete koristiti niz znakova poput stringa (kao C)
$a = "Test niza nizova";
var_dump($a);
// Povratak string(17) "Test niza nizova"
var_dump($a);
// Povratak string(1) "S"
// -- Sa ubacivanjem niza --
var_dump((niz) $a);
// Povratak niz(1) ( => string(17) "Test niza nizova")
var_dump((niz) $a);
// Povratak string(17) "S"
Norihiori
prije 1 godine
Svaki pojedinačni izraz, koliko god složen, koji počinje sa $ (tj. varijabla) može biti ()-ugrađen u niz s dvostrukim navodnicima:
Echo "Izraz ( $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 )) analizira se jednako dobro kao ". $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 ) . "da li." ;
?>
Prije 2 godine
I jedno i drugo bi trebalo da radi :(
Testiranje razreda (
public static $VAR = "statičan" ;
public const VAR = "const" ;
Javna funkcija sayHelloStatic() (
echo "zdravo: ( $this :: $VAR ) " ;
}
Javna funkcija sayHelloConst() (
echo "zdravo: ( $this ::VAR) " ; //Greška raščlanjivanja: sintaksička greška, neočekivano ")", očekuje se "["
}
}
$obj = novo testiranje();
$obj -> sayHelloStatic();
$obj -> sayHelloConst ();
prije 14 godina
Možete koristiti složenu sintaksu da stavite vrijednost i svojstava objekta I metoda objekta unutar stringa. Na primjer...
klasaTest{
javnosti$one=
1
;
javna funkcijadva() {
povratak2
;
}
}
$test= novoTest();
echo"foo{
$test->
jedan}
bar{
$test->
dva()}
"
;
?>
Izdat će "foo 1 bar 2".
Međutim, to ne možete učiniti za sve vrijednosti u vašem imenskom prostoru. Konstante klase i statička svojstva/metode neće raditi jer složena sintaksa traži "$".
klasaTest{
konstJEDAN=
1
;
}
echo"foo (Test::ONE) bar";
?>
Ovo će dati "foo (Test::one) bar". Konstante i statička svojstva zahtijevaju da razbijete niz.
prije 6 godina
Vodeće nule u nizovima se (najmanje iznenađenje) ne tretiraju kao oktalne.
Uzmite u obzir:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x je $x, y je $y"; //ispisuje "x je 123, y je 83"
drugim riječima:
* vodeće nule u numeričkim literalima u izvornom kodu se tumače kao "oktalne", c.f. strtol().
* vodeće nule u stringovima (npr. podaci koje je dostavio korisnik), kada su prebačeni (implicitno ili eksplicitno) na cijeli broj se zanemaruju i smatraju decimalnim, c.f. strtod().
prije 3 godine
Pazite da je u skladu s "pretvorbom nizova u brojeve":
ako ("123abc"==
123
) echo"(intstr == int) neispravno testira kao istinit.";
// Budući da je jedna strana broj, niz je pogrešno konvertovan iz intstr u int, koji se onda poklapa sa testnim brojem. // Tačno za sve uslovne izraze kao što su if i switch izjave (vjerovatno i while petlje)! // Ovo bi mogao biti veliki sigurnosni rizik kada se testira/koristi/čuva korisnički unos, dok se očekuje i testira samo cijeli broj. // Čini se da je jedino rješenje da 123 bude niz kao "123" tako da se konverzija ne dogodi.
?>
prije 10 godina Evo jednostavnog haka koji omogućava da stringovi sa dvostrukim navodnicima i heredocs sadrže proizvoljne izraze u sintaksi vitičastih zagrada, uključujući konstante i druge pozive funkcija:
// Hack deklaracija
// Naše igralište
$a=
3
; funkcija c($a,
$b) (povratak$a+
$b; }
//Usage // Opća sintaksa je ($_expr(...)) prije 11 godina Da ne budete pameti nemojte čitati prethodne komentare o datumima ;) Kada se oba niza mogu pretvoriti u numeričke (u ("$a" > "$b") testu) tada se koriste rezultirajući brojevi, u suprotnom se PUNI nizovi uspoređuju char-by-char: var_dump("1.22"
>
"01.23"
);
// bool(false) Prije 2 godine Mislio sam da bi bilo korisno dodati ovaj komentar kako bi se informacije barem pojavile na pravoj stranici PHP stranice. Imajte na umu da ako namjeravate koristiti niz s dvostrukim navodnicima s asocijativnim ključem, možete naići na grešku T_ENCAPSED_AND_WHITESPACE. Neki ovo smatraju jednom od manje očiglednih poruka o grešci. Izraz kao što je: $fruit=niz( Print "Ovo je$fruit[
"a"]";
// T_ENCAPSED_AND_WHITESPACE Možete ga riješiti na sljedeći način: print"Ovo je$fruit[
a]
"
;
// poništiti citat ključa Nije jasno (bar meni) zašto PHP pogrešno tumači pojedinačni navodnik unutar izraza, ali pretpostavljam da to ima neke veze sa činjenicom da navodnici nisu dio niza vrijednosti - kada se string već raščlani, samo navodnici smetati... ?
funkcija_expr($v) (povratak$v; }
$_expr=
"_expr";
definisati("qwe",
"asd");
definisati("zxc",
5
);
$b=
4
;
echo"pre{
$_expr(1
+
2
)}
objava\n";
// izlazi "pre 3 post"
echo"pre{
$_expr(qwe)}
objava\n";
// izlazi "pre asd post"
echo"pre{
$_expr(c($a,
$b)+
zxc*
2
)}
objava\n";
// izlazi "pre 17 post"
?>
var_dump("1.22.00"
>
"01.23.00"
);
//bool(true)
var_dump("1-22-00"
>
"01-23-00"
);
//bool(true)
var_dump((plutati)"1.22.00"
> (plutati)"01.23.00"
);
// bool(false)
?>
"a"=>
"jabuka",
"b"=>
"banana",
//etc
);
?>
sigurno će se raspasti.
print"Ovo je${
voće[
"a"]}
"
;
// Složena sintaksa
print"Ovo je{
$fruit[
"a"]}
"
;
// Varijacija složene sintakse
?>
Lično preferiram posljednju varijaciju jer je prirodnija i bliža onome kakav bi izraz bio izvan stringa.
