Php variabel i lockiga hängslen. Lockiga parenteser i sträng i PHP

Hej kära nybörjarprogrammerare. Låt oss fortsätta studiet av de element som utgör .

I den här artikeln kommer vi att lära oss vad som är php-uttalanden. Faktum är att vi har känt några av dem nästan sedan barndomen, vi känner dem bara som tecken (+, -, =, !, ?).

I php kallas de alla för operatorer, vilket är ganska logiskt, eftersom de utför en viss åtgärd eller operation.

Du kan till och med säga att alla utskrivna tecken som inte är en bokstav eller en siffra är operatorer i php. Men det är inte allt, eftersom det finns operatörer som består av bokstäver.

Låt oss börja i ordning.

Aritmetiska operatorer

Aritmetiska operatorer används för att utföra operationer på tal.

+ är additionsoperatorn;
— — subtraktionsoperator;
/ är divisionsoperatören;
* är multiplikationsoperatorn;
% - operatör för att erhålla resten vid delning;
++ - inkrementoperator med en (inkrement);
— — — minska operatören med en (minska)

Vid skrivning placeras vanligtvis ett mellanslag före och efter operatören. Detta görs enbart för att det ska vara enkelt att läsa koden, även om detta utrymme inte påverkar någonting, och du kan klara dig utan det om du vill.

Komplexa uttryck är sammansatta enligt de regler som antagits i aritmetiken, det vill säga multiplikation och division har företräde framför addition och subtraktion, och när båda finns i uttrycket, omges de senare inom parentes.

eko (6 + 7) * (7 + 8); // 195
?>

När du utför åtgärden att dividera ett heltal med ett heltal, i händelse av att resten erhålls, översätts resultatet automatiskt till riktigt nummer(flyttal).

eko 8/3; //2.66666666666
?>

Antalet tecken som visas för ett bråktal beror på värdet som anges i precisionsdirektivet som finns i filen php.ini. Detta är vanligtvis 12 tecken, punkten räknas inte med.

Operatorn % används vanligtvis för att avgöra om ett tal är delbart med ett annat utan rest eller inte.

eko 53328 % 4 ; //0
?>

Åtgärder med aritmetiska operatorer, med undantag för ökning och minskning, anropas binär, eftersom de involverar två operander (term + term, utdelning / divisor, etc.)

Åtgärderna för ökning och minskning kallas unär, eftersom de involverar en operand. Finns det några fler villkorlig drift, som involverar tre operander.

Operatörerna inkrement (++) och dekrement (- -) gäller endast för variabler.

Variabel typ heltal (heltal)

$nästa = 3 ;
echo ++$nästa; // 4
?>

Variabel typsträng (sträng)

$next = "abc";
echo $nästa; // abd
?>

Bokstaven "d" visas istället för bokstaven "c" eftersom det är nästa bokstav i alfabetet, och vi har ökat värdet på variabeln med en.

Exemplen visar åtgärder med en ökning, och du kan utföra åtgärder med en minskning på samma sätt.

Bitwise operatörer

Bitvisa operatorer är utformade för att arbeta på binära data. Om någon inte har en aning om vad det är så förklarar jag. binära talär siffror som 1001000011100000111000.

Eftersom sådan data nästan aldrig används i utvecklingen av webbplatser, kommer vi inte att gå in på dem i detalj. Jag ska bara visa hur de ser ut, så att när du möter sådana symboler kan du föreställa dig vad du har att göra med.

& - bitvis anslutning AND (och);
~ — bitvis negation (inte);
| - bitvis union ELLER (eller);
^ - bitvis undantag ELLER (xor);
<< — сдвиг влево битового значения операнда;
>> - skift till höger om bitvärdet för operanden;

Möte med dessa operatörer är ganska troligt, eftersom binära data används i stor utsträckning i utvecklingen av program för Datorgrafik. Men för att studera dem, om någon behöver det, måste du ta en separat kurs om en annan resurs.

Jämförelseoperatörer

Jämförelseoperatorer är logiska operatorer och används för att jämföra variabler. Matriser och objekt kan inte jämföras med dem.

> - större än operatorn;
=> - större än eller lika med operatorn;
< — оператор меньше;
<= — оператор меньше или равно;
== - jämställdhetsoperatör;
!= — ojämlikhetsoperator;
=== - ekvivalensoperator (variabelns värde och typ är lika);
!== - icke-ekvivalensoperator;

Som ett resultat av jämförelsen visas antingen en på skärmen, vilket motsvarar sant (sant), eller tom rad, vilket motsvarar falskt (falskt).

eko 1 > 0; // 1
eko 1< 0 ; // пустая строка
eko 1 => 0; // 1
eko 1 == 1; // 1
?>

Så i sig själva används jämförelseoperatörer nästan aldrig. Deras huvudsakliga syfte är att arbeta tillsammans med if-satsen.

Villkorliga uttalanden om, else, elseif .

Villkorliga uttalanden kallas så eftersom de är utformade för att testa ett visst tillstånd, beroende på vilken en eller annan åtgärd som utförs.

Som ett argument tar if-satsen en boolesk variabel eller ett uttryck. Om villkoret är sant, visas resultatet, om inte sant, en tom sträng.

om ($nästa< $nexT)
{
eko "Möjlig nederbörd"; // Dränerad Regn möjligt
}
?>

$next = "Luftfuktighet 80%";
$nexT = "Luftfuktighet 90%";
if ($next > $nexT)
{
eko "Möjlig nederbörd"; // Mata ut tom sträng
}
?>

Om programmet behöver ställa in två åtgärder, varav en kommer att utföras när värdet är sant och den andra när det är falskt, används else-satsen tillsammans med if-satsen

$next = "Luftfuktighet 80%";
$nexT = "Luftfuktighet 90%";
if ($next > $nexT)
{
eko "Möjlig nederbörd";
}
annan
{
echo "Nerbörd förväntas inte";
}
?>

I det här fallet kommer "Nerbörd förväntas inte" att visas, och om "Mer"-tecknet ändras till "Mindre" i uttrycket, kommer "Nerbörd är möjligt" att visas. Så här kontrollerar villkorliga uttalanden villkoret och matar ut det korrekta resultatet enligt det.

Mycket ofta finns det ett behov av att specificera mer än två villkor, och sedan, för att kontrollera dem sekventiellt, används elseif-operatorn.

if ($next > $nexT)
{
eko "Rensa";
}
elseif ($next<= $nexT)
{
eko "Snö";
}
elseif ($next >= $nexT)
{
eko "Regn";
}
elseif ($next == $nexT)
{
eko "torka";
}
annan
{
eko "Möjlig nederbörd";
}
?>

Detta program kommer att skriva ut "Snö". Om inget av villkoren matchade, skulle "Nerbörd är möjlig" visas.

If-satsen kan innehålla så många elseif-block som du vill, och bara en else-sats.

En alternativ notation är tillåten - utan hängslen. I det här fallet slutar raderna av if, else, elseif-satser med ett kolon, och hela konstruktionen är nyckelord(operatör) endif .

$next = "Luftfuktighet 50%";
$nexT = "Luftfuktighet 60%";
om ($nästa<= $nexT):

eko "Snö";

elseif ($next >= $nexT):

eko "Regn";

elseif ($next == $nexT):

eko "torka";

annan:

eko "Möjlig nederbörd";
endif;
?>

Logiska operatorer

Logiska operatorer liknar bitvisa operatorer. Skillnaden mellan dem är att de första arbetar med logiska variabler och de andra med siffror.

Logiska operatorer används när du behöver kombinera flera villkor, vilket kommer att minska antalet if-satser, vilket i sin tur minskar sannolikheten för fel i koden.

&& - anslutande förbund AND;
och - även AND, men med lägre prioritet;
|| - delande fackförening OR;
eller - även ELLER, men med lägre prioritet;
xor - exklusivt ett element ELLER;
! - förnekande;

Lägre prioritet innebär att om det finns båda operatörerna exekveras den med högre prioritet först.

I framtiden, med hjälp av exempel på mer komplexa skript, kommer vi att uppehålla oss mer i detalj vid logiska operatorer.

uppdragsoperatör

Tilldelningsoperatorn = tilldelar värdet för den högra operanden till den vänstra operanden.

$next = "Hej"
echo "Hej" // Hej
?>

punktoperator

Punktoperatorn separerar heltalsdelen av ett tal från bråkdelen och sammanfogar flera strängar och ett tal till en hel sträng.

$nästa = 22 ;
echo "Idag efter" .$nästa. "frost förväntas"; // Frysning väntas efter 22 idag
?>

Operatör för parenteser

Precis som i matematik ger parentesoperatorn företräde åt handlingen som är innesluten i dem.

Datan inom parentes exekveras först och sedan allt annat.

Operatör för lockiga hängslen

I php finns det tre sätt, eller till och med stilar, att placera lockiga hängslen.

1. BSD-stil - parenteser är vänsterjusterade.

if ($nästa)
{

}

2. GNU-stil - parenteser är justerade med ett indrag från vänsterkanten

if ($nästa)
{
echo "Hej kära nybörjare programmerare";
}

3. K&R-stil - fästet öppnas i operatörslinjen

if ($nästa)(
echo "Hej kära nybörjare programmerare";
}

Redan från början måste du välja en av stilarna och i framtiden, när du skriver skript, använd bara den. Och det spelar ingen roll vilken stil du väljer. Det är viktigt att det är konsekvent genom hela programmet.

För nu tycker jag att det räcker. I princip kan inte bara tecken utan även funktioner och andra element vara operatörer, så det är mycket svårt att lista dem alla, och det finns inget behov.

Det räcker med att ha en uppfattning om grunderna. Och resten kommer att analyseras på praktiska exempel.

En irländare vandrar genom Sheremetyevo flygplats i tårar. En av de anställda bestämde sig för att sympatisera:
– Saknar du ditt hemland?
- Inte alls. Jag tappade precis allt mitt bagage
- Hur kunde detta hända?
"Jag förstår inte mig själv. Det verkar som att du satt i kontakten

Enkel syntax

Om tolken stöter på ett dollartecken ($), fångar den så många tecken som möjligt för att bilda ett giltigt variabelnamn. Om du vill ange slutet på ett namn, omslut variabelnamnet med klammerparenteser.

$beer = "Heineken" ;
echo "$öls smak är fantastisk" ; // fungerar, """ är ett ogiltigt tecken för ett variabelnamn
echo "Han drack några $öl" ; // fungerar inte, "s" är ett giltigt tecken för ett variabelnamn
echo "Han drack några $(öl)s" ; // Arbetar
echo "Han drack några ($öl)s" ; // Arbetar
?>

På liknande sätt kan ett arrayelement bearbetas ( array) eller objektegenskap ( objekt). I matrisindex, den avslutande hakparentesen ( ] ) markerar slutet på indexdefinitionen. Samma regler gäller för objektegenskaper som för enkla variabler, även om det inte finns något knep för dem som variabler.

// Dessa exempel handlar specifikt om att använda arrayer internt
// rader. Utanför strängar, bifoga alltid strängnycklarna till din
// array inom citattecken och använd inte utanför strängar (parenteser).

// Låt oss visa alla fel
error_reporting(E_ALL);

$fruits = array("strawberry" => "röd" , "banan" => "gul" );

// Fungerar, men observera att det fungerar annorlunda utanför den citerade strängen
eko "En banan är $frukt.";

//Arbetar
eko "En banan är ($fruits["banan"]).";

// Fungerar, men PHP, som beskrivs nedan, letar först efter
// konstant banan.
eko "En banan är ($frukter).";

// Fungerar inte, använd lockiga hängslen. Detta kommer att orsaka ett bearbetningsfel.
eko "En banan är $frukter["banan"].";

// Arbetar
echo "En banan är". $frukter [ "banan" ] . "." ;

// Arbetar
eko "Denna kvadrat är $square->bredd meter bred.";

// Fungerar inte. Se komplex syntax för en lösning.
eko "Denna fyrkant är $square->width00 centimeter bred.";
?>

För mer utmanande uppgifter du kan använda komplex syntax.

Komplex (lockig) syntax

Denna syntax kallas komplex inte för att den är svår att förstå, utan för att den tillåter användning av komplexa uttryck.

Faktum är att du kan inkludera valfritt namnavstånd på en rad med denna syntax. Du skriver helt enkelt uttrycket på samma sätt som du skulle göra utanför strängen och lindar sedan in det i ( och ). Eftersom du inte kan undkomma "(", kommer denna syntax bara att kännas igen när $ direkt följer efter (. (Använd "(\$" eller "\($" för att visa "($"). Några illustrativa exempel:

// Låt oss visa alla fel
error_reporting(E_ALL);

$great = "fantastiskt" ;

// Fungerar inte, utgångar: Det här är (fantastiskt)
echo "Detta är ($bra)" ;

// Fungerar, utgångar: Det här är fantastiskt
echo "Detta är ($bra)" ;
echo "Detta är $(bra)" ;

// Arbetar
eko "Denna fyrkant är ($square->width)00 centimeter bred.";

// Arbetar
eko "Detta fungerar: ($arr)";

// Detta är fel av samma anledning som $foo har fel utanför
// rader. Det kommer med andra ord fortfarande att fungera
// men eftersom PHP letar efter foo-konstanten först, kommer detta att anropa
// E_NOTICE nivåfel (odefinierad konstant).
eko "Detta är fel: ($arr)";

// Arbetar. När du använder flerdimensionella arrayer, inuti
// strängar använder alltid lockiga hängslen
eko "Detta fungerar: ($arr["foo"])";

// Arbetar.
echo "Detta fungerar: " . $arr [ "foo" ][ 3 ];

eko "Du kan till och med skriva ($obj->values->name)";

eko "Detta är värdet på variabeln som heter $name: ($($name))";
?>

Tecken i strängar kan användas och modifieras genom att ange deras förskjutning från början av strängen, med början på noll, med klammerparenteser efter strängen. Här är några exempel:

// Hämta det första tecknet i strängen
$str = "Detta är ett test." ;
$först = $str ( 0 );

// Hämta det tredje tecknet i strängen
$tredje = $str ( 2 );

// Hämta det sista tecknet i strängen
$str = "Det är fortfarande ett test.";
$last = $str (strlen ($str) - 1);

// Ändra det sista tecknet i strängen
$str = "Titta på havet";
$str ( strlen ($str )- 1 ) = "i" ;

?>

Strängfunktioner och operatorer

Strängoperatorer

Olika programmeringsspråk använder olika strängsammansättningsoperatorer (union). Till exempel använder Pascal operatorn "+". Använda i PHP-operatör"+" för strängsammansättning är felaktig: om strängarna innehåller siffror, kommer operationen att lägga till två siffror att utföras istället för att sammanfoga strängarna.

PHP har två operatörer som utför sammanlänkning.

Den första är sammanlänkningsoperatorn ("."), som returnerar sammansättningen av vänster- och högerargumenten.

Den andra ärtorn, som lägger till det högra argumentet till det vänstra argumentet.

Låt oss ta ett konkret exempel:

$a = "hej" ;
$b = $a . "Värld!" ; // $b innehåller strängen "Hello World!" – Det här är en sammanlänkning

$a = "hej" ;
$a .= "Världen!" ; // $a innehåller strängen "Hello World!" – Det här är ett uppdrag med sammanlänkning
?>

Operatörer för strängjämförelse

Jämförelseoperatorerna == och != rekommenderas inte för strängjämförelser eftersom de kräver typkonvertering. Exempel:

$ x = 0 ;
$ y = 1 ;
if ($x == "") eko "

x - tom sträng

" ;
if($y=="") eko "

y - tom sträng

" ;
// Utgångar:
// x - tom sträng
?>

Det här skriptet talar om för oss att $x är en tom sträng. Detta beror på att den tomma strängen ("") först behandlas som 0 och först sedan som "tom". I PHP jämförs operander som strängar endast om de båda är strängar. Annars jämförs de som siffror. I det här fallet kommer alla strängar som PHP inte kan konvertera till ett tal (inklusive den tomma strängen) att behandlas som 0.

Exempel på strängjämförelse:

$ x = "Sträng" ;
$y = "Sträng" ;
$z = "Linje" ;
om ($x == $z ) eko "

Rad X är lika med rad Z

" ;
if ($ x == $ y ) eko "

Rad X är lika med rad Y

" ;
om ($ x != $ z ) eko "

Sträng X är INTE lika med sträng Z

" ;
// Utgångar:
// Sträng X är lika med sträng Y

?>

För att undvika förvirring och typkonverteringar rekommenderas att du använder ekvivalensoperatorn när du jämför strängar. Ekvivalensoperatorn låter dig alltid jämföra strängar korrekt, eftersom den jämför värden både efter värde och typ:

$ x = "Sträng" ;
$y = "Sträng" ;
$z = "Linje" ;
om ($x === $z ) eko "

Rad X är lika med rad Z

" ;
if ($ x === $ y ) eko "

Rad X är lika med rad Y

" ;
om ($ x !== $ z ) eko "

Sträng X är INTE lika med sträng Z

" ;
// Utgångar:
// Sträng X är lika med sträng Y
// Sträng X är INTE lika med sträng Z
?>

I det förra inlägget tittade vi på den villkorliga operatorsyntaxen i PHP. Det här inlägget kommer att fokusera på operatörsfästen. Du kommer att stöta på dem konstant. Detta är grundkonceptet för alla programmeringsspråk.

På frågan om vad operatorparenteser är, hjälper Wikipedia oss att svara:

Operatörsfästen- parenteser eller kommandon som definierar ett block av kommandon i programmeringsspråket, uppfattat som en helhet, som ett kommando.

I Pascal språk för att beteckna operatörskonsoler används konstruktionen Börja…. slutet. På C-liknande språk (som inkluderar PHP), beskrivs operatörskonsolerna med hjälp av symbolerna {…} .

De där. med andra ord, flera kommandon inom parentes behandlas som ett kommando.

Det fanns ett exempel i artikeln om villkor i PHP:

$b) ( echo "Variabel A är större än B"; ) else ( echo "Variabel B är större än A"; ) ?>

I det här exemplet används operatörskonsoler 2 gånger. De ramar operatörer

• eko"Variabel A är större än B";
• eko"Variabel B är större än A";

I det här exemplet är bara 1 påstående inom parentes, så det motsvarar att skriva så här:

$b) eko "Variabel A är större än B"; annars eko "Variabel B är större än A"; ?>

Syntax:

Om (villkor) uttryck 1; annat uttryck 2;

Låt oss säga att vi vill att ytterligare en rad ska visas om villkoret inte är uppfyllt. Vi ändrar också värdena på våra variabler så att nu $a var > $b. Låt oss ändra vår kod:

$b) echo "Variabel A är större än B."; else echo "Variabel B är större än A."; echo "Ja...ja A är faktiskt mindre än B."; ?>

Vi kör ... Vad ser vi på skärmen:

Variabel A är större än B. Ja.. ja A är faktiskt mindre än B.

Det finns ett fel här någonstans. Som du kanske har gissat är hela poängen att eftersom vårt tillstånd är sant (a > b), exekveras koden:

Echo "Variabel A är större än B.";

I gren annan vi har bara ett uttryck:

Echo "Variabel B är större än A.";

Följande uttryck kommer att exekveras oavsett villkoret. Så här:

$b) echo "Variabel A är större än B."; else echo "Variabel B är större än A."; echo "Ja...ja A är faktiskt mindre än B."; ?>

Nu använder vi operatorparenteser och kombinerar 2 uttryck i en gren annan:

$b) ( echo "Variabel A är större än B. "; ) else ( echo "Variabel B är större än A. "; eko "Ja..ja A är faktiskt mindre än B. "; ) ?>

Koden har blivit mycket tydligare. Nu PHP förstår att om villkoret ($a > $b) inte är uppfyllt, ska 2 rader visas. Och om villkoret är sant - bara en.

Min du stora råd- använd alltid satsparenteser, även om du inte behöver kombinera flera satser till ett block. Faktum är att:

• koden ser bättre ut så här. När vi tar en snabb titt på koden ser vi dess individuella block, och inte en sallad av bokstäver och siffror.
• gammal kod måste ofta ändras. Om du inte hade operatörsparenteser, och du (som i vårt fall) lade till någon kod, kommer programlogiken att vara felaktig. Du kanske inte ens märker det direkt.

Kommentar: I PHP 7.0.0 på 64-bitars plattformar finns det inga nåbara stränglängder, på 32-bitars system och över tidiga versioner PHP, strängar får inte vara större än 2 GB (2147483647 byte).

Syntax

En sträng kan definieras med fyra olika sätt:

• enstaka citat
• dubbla citattecken
• nowdoc-syntax (sedan PHP 5.3.0)

Enstaka citat

Det enklaste sättet att definiera en sträng är att omge den med enkla citattecken (symbol " ).

Om du vill använda ett enda citattecken inom en sträng, undviker du det med ett snedstreck ( \ ). Om du behöver skriva själva snedstrecket, duplicera det ( \\ ). Alla andra snedstreck kommer att tolkas som vanliga tecken, vilket innebär att om du försöker använda andra escape-sekvenser som t.ex. \r eller \n, kommer de att matas ut som de är istället för något speciellt beteende.

eko "det här är en enkel sträng";

eko "Du kan också infoga i rader
nylinjekaraktär som denna,
Det här är okej";

// Utgångar: En dag sa Arnold: "Jag kommer tillbaka"
eko "En dag sa Arnold, "Jag kommer tillbaka"";

eko "Har du tagit bort C:\\*.*?";

// Utgångar: Tog du bort C:\*.*?
echo "Har du tagit bort C:\*.*?" ;

// Utdata: Detta kommer inte att utökas: \n ny rad
eko "Detta kommer inte att expandera: \n nyrad";

// Utskrifter: $expand-variabler utökas inte heller med $either
eko "Variabler $expand också $either expanderas inte";
?>

Dubbla citattecken

Om strängen är omgiven av dubbla citattecken ("), känner PHP igen följande specialteckens escape-sekvenser:

Escape-sekvenser

Efterföljd	Menande
\n	nylinje (LF eller 0x0A (10) i ASCII)
\r	vagnretur (CR eller 0x0D (13) i ASCII)
\t	horisontell flik (HT eller 0x09 (9) i ASCII)
\v	vertikal flik (VT eller 0x0B (11) i ASCII) (sedan PHP 5.2.5)
\e	escape-tecken (ESC eller 0x1B(27) i ASCII) (sedan PHP 5.4.4)
\f	sidflöde (FF eller 0x0C (12) i ASCII) (från och med PHP 5.2.5)
\\	snedstreck
\$	dollartecken
\"	dubbelt citat
\{1,3}	sekvens av tecken som matchar ett reguljärt uttryck av ett tecken i oktal som tyst svämmar över för att passa in i en byte (dvs. "\400" === "\000")
\x(1,2)	en sekvens av tecken som matchar ett reguljärt teckenuttryck i hexadecimal form
\u(+)	sekvens av tecken som matchar ett reguljärt Unicode-teckenuttryck som mappas till en sträng i UTF-8-representation (tillagt i PHP 7.0.0)

Precis som med en sträng omsluten av enkla citattecken, kommer escape-tecknet att skriva ut själva escape-tecknet. Före PHP 5.1.1, snedstrecket in \($var) inte tryckt.

Heredoc

Det tredje sättet att definiera strängar är att använda heredoc-syntaxen: <<< . Efter detta uttalande måste du ange en identifierare och sedan en ny rad. Efter det kommer själva raden, och sedan samma identifierare som stänger infogningen.

Linje måste börja med en avslutande identifierare, dvs. den ska finnas i den första kolumnen på raden. Dessutom måste identifieraren följa samma namnregler som alla andra PHP-taggar: endast innehålla alfanumeriska tecken och understreck, och får inte börja med en siffra (understreck är tillåtna).

Uppmärksamhet

Det är mycket viktigt att notera att strängen med den avslutande identifieraren inte får innehålla andra tecken, förutom semikolon ( ; ). Det betyder att ID får inte indragas och att det inte kan finnas några mellanslag eller tabbar före eller efter semikolon. Det är också viktigt att förstå att det första tecknet före den avslutande identifieraren måste vara ett nyradstecken, enligt definitionen av ditt operativsystem. Till exempel, på UNIX-system, inklusive macOS, är detta \n. Den avslutande identifieraren måste också omedelbart följas av en ny rad.

Om denna regel bryts och den avslutande identifieraren inte är "ren", anses det inte finnas någon avslutande identifierare och PHP kommer att fortsätta att söka efter den. Om, i det här fallet, den korrekta avslutande identifieraren aldrig hittas, kommer detta att orsaka ett analysfel med ett radnummer i slutet av skriptet.

Beispiel #1 Felaktig syntaxexempel

klass foo(
offentlig $bar =<<bar
EOT;
// utfyllnad före den avslutande identifieraren är inte tillåten
}
?>

Beispiel #2 Korrekt syntaxexempel

klass foo(
offentlig $bar =<<bar
EOT;
}
?>

Heredoc kan inte användas för att initiera klassfält. Från och med PHP 5.3 gäller denna begränsning endast heredocs som innehåller variabler i dem.

Heredoc-text beter sig på samma sätt som en sträng med dubbla citat utan att ha dem. Det betyder att du inte behöver undkomma citattecken i heredoc, men du kan fortfarande använda ovanstående escape-sekvenser. Variabler hanteras, men du måste vara lika försiktig när du använder komplexa variabler i en heredoc som när du arbetar med strängar.

Beispiel #3 heredoc strängdefinitionsexempel

$str =<<Linje exempel,
spänner över flera linjer
använder heredoc-syntaxen.
EOD;

Klass foo
{
var $foo ;
var $bar ;

Funktion __construct()
{
$this -> foo = "foo" ;
$this ->
}
}

$foo = newfoo();
$name = "Namn" ;

eko<<Mitt namn är " $name ". Jag skriver $foo -> foo .
Nu tar jag ut( $foo -> bar [ 1 ]) .
Detta bör mata ut ett versalt "A": \x41
EOT;
?>

Jag heter "Namn". Jag skriver Foo. Nu matar jag ut Bar2. Detta bör mata ut ett versalt "A": A

Det är också möjligt att använda heredoc-syntax för att skicka data genom funktionsargument:

Sedan version 5.3.0 har det blivit möjligt att initiera statiska variabler och klassegenskaper/konstanter med heredoc-syntaxen:

Beispiel #5 Använder heredoc för att initiera statiska variabler

// Statiska variabler
functionfoo()
{
statisk $bar =<<Det finns inget här...
märka;
}

// Klasskonstanter/egenskaper
klass foo
{
const BAR =<<Ett exempel på att använda en konstant
FOO BAR;

Offentlig $bas =<<Exempel på fältanvändning
FOO BAR;
}
?>

Från och med PHP 5.3.0 är det också möjligt att omge Heredoc-identifieraren med dubbla citattecken:

Nowdoc

Nowdoc är samma för strängar med enkla citattecken som heredoc är för strängar med dubbla citat. Nowdoc liknar heredoc, men inuti den inga ersättningar görs. Denna konstruktion är idealisk för att bädda in PHP-kod eller andra stora textblock utan att behöva undkomma den. I detta är det lite likt SGML-konstruktionen. genom att förklara att ett textblock inte är avsett att bearbetas.

Nowdoc indikeras med samma sekvens <<< , som används i heredoc, men identifieraren som följer den är omsluten av enkla citattecken, till exempel, <<<"EOT" . Alla villkor som gäller för heredoc-identifierare gäller även för nowdoc, speciellt de som gäller för den avslutande identifieraren.

Beispiel #7 nowdoc exempel

eko<<<"EOD"
textexempel,
spänner över flera linjer
använder nowdoc-syntax. Omvända snedstreck behandlas alltid bokstavligt,
till exempel \\ och \".
EOD;

Resultatet av att köra detta exempel:

Ett exempel på text som spänner över flera rader med syntaxen nowdoc. Omvänt snedstreck behandlas alltid bokstavligt, som \\ och \".

Exempel #8 Nowdoc-strängcitatexempel med variabler

/* Mer komplext exempel med variabler. */
klass foo
{
offentliga $foo ;
offentlig $bar ;

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

$foo = newfoo();
$name = "Namn" ;

eko<<<"EOT"
Mitt namn är "$name". Jag skriver $foo->foo.
Nu skriver jag ($foo->bar).
Detta bör inte mata ut ett stort "A": \x41
EOT;
?>

Resultatet av att köra detta exempel:

Mitt namn är "$name". Jag skriver $foo->foo. Nu skriver jag ($foo->bar). Detta bör inte mata ut ett stort "A": \x41

Exempel #9 Statisk dataexempel

klass foo(
offentlig $bar =<<<"EOT"
bar
EOT;
}
?>

Kommentar:

nowdoc-stöd lades till i PHP 5.3.0.

Bearbetning av variabler

Om en sträng anges med dubbla citattecken eller med en heredoc, bearbetas variablerna inuti den.

Det finns två typer av syntax: enkel och komplex. Den enkla syntaxen är enklare och bekvämare. Det gör det möjligt att bearbeta en variabel, ett matrisvärde ( array) eller objektegenskaper ( objekt) med minimal ansträngning.

Komplex syntax kan identifieras av de lockiga klammerparenteserna som omger uttrycket.

Enkel syntax

Om tolken stöter på ett dollartecken ( $ ), fångar den så många tecken som möjligt för att bilda det korrekta variabelnamnet. Om du vill ange slutet på ett namn, omslut variabelnamnet med klammerparenteser.

$juice = "äpple" ;

echo "Han drack lite $juicejuice." . PHP_EOL ;

// Felaktig. "s" är ett giltigt tecken för ett variabelnamn, men variabelnamnet är $juice.
echo "Han drack lite juice gjord av $juices ." ;

// Korrekt. Slutet på variabelnamnet är strikt specificerat med parenteser:
echo "Han drack lite juice gjord av $( juice ) s." ;
?>

Resultatet av att köra detta exempel:

Han drack lite äppeljuice. Han drack lite juice gjord av. Han drack lite juice gjord av äpplen.

Ett element i en array ( array) eller objektegenskap ( objekt). I matrisindex, den avslutande hakparentesen ( ] ) markerar slutet på indexdefinitionen. Samma regler gäller för objektegenskaper som för enkla variabler.

Exempel #10 Enkelt syntaxexempel

define("KOOLAID" , "koolaid1" );
$juices = array("äpple" , "orange" , "koolaid1" => "lila" );

echo "Han drack lite $juice [0] juice." . PHP_EOL ;
echo "Han drack några $juices [ 1 ] juice." . PHP_EOL ;
echo "Han drack lite $juices [ koolaid1 ] juice." . PHP_EOL ;

klass människor(
public $john = "John Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Public $smith = "Smith" ;
}

$people = nya människor();

echo " $people -> john drack lite $juices [ 0 ] juice." . PHP_EOL ;
echo " $people -> john sa sedan hej till $people -> jane ." . PHP_EOL ;
echo " $people -> john "s fru hälsade $people -> robert." . PHP_EOL ;
echo " $people -> robert hälsade de två $people -> smederna." ; // Kommer inte att fungera
?>

Resultatet av att köra detta exempel:

Han drack lite äppeljuice. Han drack lite apelsinjuice. Han drack lite lila juice. John Smith drack lite äppeljuice. John Smith sa då hej till Jane Smith. John Smiths fru hälsade Robert Paulsen och Robert Paulsen hälsade de två.

PHP 7.1.0 har lagt till stöd negativ numeriska index.

Exempel #11 Negativa numeriska index

$string = "sträng" ;
eko "Tecknet vid index -2 är$string [- 2 ] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
eko "Om du ändrar tecknet i position -3 till 'o' får du följande rad:$string ." , PHP_EOL ;
?>

Resultatet av att köra detta exempel:

Tecknet med index -2 är n. Att ändra tecknet vid position -3 till "o" ger följande sträng: stark

För allt mer komplext, använd komplex syntax.

Komplex (lockig) syntax

Det kallas komplex inte för att det är svårt att förstå, utan för att det tillåter användning av komplexa uttryck.

Varje skalär variabel, matriselement eller objektegenskap som är mappad till en sträng kan representeras i en sträng med denna syntax. Skriv bara uttrycket precis som du skulle göra utanför strängen och omslut det sedan { Och } . Eftersom den { inte kan escapes, denna syntax kommer bara att kännas igen när $ följer direkt efter { . Använda sig av {\$ att skriva ut {$ . Några illustrativa exempel:

// Visa alla fel
error_reporting(E_ALL);

$great = "bra" ;

// Fungerar inte, utdata: Detta (bra)
echo "Detta är ($bra)" ;

// Fungerar, utgångar: Det här är bra
echo "Detta är ($bra)" ;

// Arbetar
eko "Det här torget är brett( $square -> width ) 00 centimeter." ;

// Fungerar, citerade nycklar fungerar bara med syntax för krulliga parenteser
echo "Detta fungerar: ( $arr [ "nyckel" ]) " ;

// Arbetar
echo "Detta fungerar: ( $arr [ 4 ][ 3 ]) " ;

// Detta är fel av samma anledning som $foo är utanför
// rader. Det kommer med andra ord fortfarande att fungera
// men eftersom PHP letar efter foo-konstanten först, kommer detta att anropa
// E_NOTICE nivåfel (odefinierad konstant).
eko "Det är inte rätt:( $arr [ foo ][ 3 ]) " ;

// Arbetar. När du använder flerdimensionella arrayer inuti
// strängar använder alltid lockiga hängslen
echo "Detta fungerar: ( $arr [ "foo" ][ 3 ]) " ;

// Arbetar.
echo "Detta fungerar: " . $arr [ "foo" ][ 3 ];

eko "Detta fungerar också:($obj -> värden [3]-> namn) " ;

eko "Detta är värdet på variabeln som heter$name : ($( $name )) " ;

eko "Detta är värdet på variabeln efter namn, som returneras av funktionen getName():($( getName ())) ";

eko "Detta är värdet på variabeln efter namn som returneras av \$object->getName():($( $object -> getName ())) " ;

// Fungerar inte, utdata: Det här är vad getName() returnerar: (getName())
eko "Det här är vad getName() returnerar: (getName())";
?>

Det är också möjligt att komma åt objektegenskaper inom strängar med denna syntax.

klass foo(
var $bar = "Jag är bar." ;
}

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

Resultatet av att köra detta exempel:

Jag är bar. Jag är bar.

Kommentar:

Funktioner, metodanrop, statiska klassvariabler och klasskonstanter fungerar internt {$} , sedan PHP version 5. Det angivna värdet kommer dock att behandlas som ett variabelnamn i samma sammanhang som strängen där det definieras. Använd enkla lockiga hängslen ( {} ) fungerar inte för att komma åt värdena för funktioner, metoder, klasskonstanter eller statiska klassvariabler.

// Visa alla fel
error_reporting(E_ALL);

klass öl (
const läsk = "rootbeer" ;
public static $ale = "ipa" ;
}

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

// Det här fungerar, utgångar: Jag skulle vilja ha A & W
echo "Jag skulle vilja ha ($( öl :: läsk )) \n" ;

// Detta fungerar också, utgångar: Jag skulle vilja Alexander Keiths
echo "Jag skulle vilja ha ($( öl :: $ale )) \n" ;
?>

Få åtkomst till ett tecken i en sträng och ändra det

Tecken i strängar kan användas och modifieras genom att ange deras offset från början av strängen, med början på noll, inom hakparenteser efter strängen, till exempel $str . Tänk på en sträng för detta ändamål som en uppsättning tecken. Om du behöver skaffa eller ersätta mer än 1 tecken kan du använda funktionerna substr() Och substr_replace().

Kommentar: sedan PHP 7.1.0 stöds negativa offsetvärden. De sätter offset från slutet av strängen. Tidigare orsakade negativa offset ett nivåfel E_NOTICE vid läsning (retur en tom sträng) eller E_VARNING vid skrivning (låter strängen vara oförändrad).

Kommentar: Ett tecken i en sträng kan också nås med hängslen, som $str(42) .

Uppmärksamhet

Ett försök att skriva till en offset utanför strängen kommer att fylla strängen med blanksteg upp till den offseten. Icke-heltalstyper kommer att konverteras till heltal. Fel offsettyp kommer att orsaka nivåfel E_VARNING. Endast det första tecknet i den tilldelade strängen används. Från och med PHP 7.1.0 kommer att tilldela en tom sträng orsaka ett allvarligt fel. Tidigare, i det här fallet, tilldelades en nollbyte (NULL).

Uppmärksamhet

Strängar i PHP är internt arrayer av byte. Som ett resultat av detta är åtkomst till eller modifiering av en sträng med offset inte multibyte säker, och bör endast göras med strängar i enkelbyte-kodningar som ISO-8859-1.

Kommentar: Sedan PHP 7.1.0 orsakar användningen av ett tomt index ett fatalt fel, tidigare i ett sådant fall konverterades strängen till en array utan förvarning.

Exempel #12 Flera exempelsträngar

// Hämta det första tecknet i strängen
$str = "Detta är ett test." ;
$först = $str [0 ];

// Hämta det tredje tecknet i strängen
$tredje = $str [2 ];

// Hämta det sista tecknet i strängen
$str = "Detta är fortfarande ett test." ;
$last = $str [ strlen($str )- 1 ];

// Ändra det sista tecknet i strängen
$str = "Titta på havet" ;
$str [ strlen ($str )- 1 ] = "e" ;

?>

Från och med PHP 5.4 måste offset i en sträng vara antingen ett heltal eller en sträng som innehåller siffror, annars kommer en varning att utfärdas. Tidigare gavs en offset av en sträng som "foo", utan förvarning omvandlades till 0 .

Exempel #13 Skillnader mellan PHP 5.3 och 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" ]));
?>

Resultatet av att köra detta exempel i PHP 5.3 är:

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

Resultatet av att köra detta exempel i PHP 5.4 är:

string(1) "b" bool(true) Varning: Olaglig strängoffset "1.0" i /tmp/t.php på rad 7 string(1) "b" bool(false) Varning: Olaglig strängoffset "x" i / tmp/t.php på rad 9 string(1) "a" bool(false) string(1) "b" bool(false)

Kommentar:

Försök att komma åt variabler av andra typer (exklusive arrayer eller objekt som implementerar vissa gränssnitt) med eller {} återvänder tyst NULL.

Kommentar:

PHP 5.5 lade till stöd för åtkomst av tecken i strängliteraler med hjälp av syntaxen eller {} .

Det finns många användbara funktioner för att modifiera strängar.

Huvudfunktionerna beskrivs i avsnittet strängfunktioner och för avancerad sökning och ersättning, Perl-kompatibla reguljära uttrycksfunktioner.

Konvertera till sträng

Värdet kan konverteras till en sträng med hjälp av en cast (sträng), eller funktioner strval(). I uttryck där en sträng behövs sker konverteringen automatiskt. Detta händer när du använder funktioner eko eller skriva ut, eller när värdet på en variabel jämförs med en sträng. Att läsa avsnitten Typer och Typmanipulation i manualen kommer att göra följande tydligare. se även settype().

Matriser konverteras alltid till strängar "array", så du kan inte visa innehållet i arrayen ( array) använder sig av eko eller skriva ut för att se vad den innehåller. För att visa ett enskilt element, använd något liknande echo $arr["foo"]. Se nedan för tips om hur du visar/visar allt innehåll.

För att konvertera en typvariabel "Objekt" per typ sträng den magiska metoden __toString används.

Menande NULL alltid omvandlas till den tomma strängen.

Som du kan se ovan ger direkt strängläggning av arrayer, objekt eller resurser ingen användbar information om själva värdena, annat än deras typer. Ett mer lämpligt sätt att mata ut värden för felsökning är att använda funktioner print_r() Och var_dump().

De flesta värden i PHP kan konverteras till en sträng för permanent lagring. Denna metod kallas serialisering och kan göras med funktionen serialisera().

Konvertera strängar till tal

Om strängen känns igen som ett numeriskt värde, bestäms det resulterande värdet och typen enligt följande.

Om strängen inte innehåller något av tecknen ".", "e" eller "E", och värdet på talet passar inom intervallet av heltal (definierad PHP_INT_MAX), kommer strängen att kännas igen som ett heltal ( heltal). I alla andra fall anses det vara ett flyttal ( flyta).

Värdet bestäms av den initiala delen av strängen. Om strängen börjar med ett giltigt numeriskt värde kommer det värdet att användas. Annars blir värdet 0 (noll). Ett giltigt numeriskt värde är en eller flera siffror (som kan innehålla en decimalkomma), eventuellt föregås av ett tecken, följt av en valfri exponent. Exponenten är "e" eller "E" följt av en eller flera siffror.

$foo = 1 + "10.5" ; // $foo är en flöte (11,5)
$foo = 1 + "-1.3e3" ; // $foo är en flöte (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo är ett heltal (1)
$foo = 1 + "bob3" ; // $foo är ett heltal (1)
$foo = 1 + "10 små grisar" ; // $foo är ett heltal (11)
$foo = 4 + "10.2 Små grisar" ; // $foo är en flöte (14.2)
$foo = "10.0 grisar" + 1 ; // $foo är en flöte (11)
$foo = "10.0 grisar" + 1.0 ; // $foo är en flöte (11)
?>

Se avsnittet strtod(3) i Unix-dokumentationen för mer information om denna konvertering.

Om du vill testa något av exemplen i det här avsnittet, kopiera och klistra in det och följande rad för att se vad som händer:

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

Förvänta dig inte att få teckenkoden genom att konvertera den till ett heltal (som görs till exempel i C). För att konvertera tecken till deras ASCII-koder och vice versa, använd funktionerna ord() Och chr().

Strängtyp Implementeringsdetaljer

7 år sedan

Dokumentationen nämner inte, men ett avslutande semikolon i slutet av heredoc tolkas faktiskt som ett riktigt semikolon, och leder som sådant ibland till syntaxfel.

$foo =<<abcd
SLUTET;
?>

Detta gör inte:

foo(<<abcd
SLUTET;
);
// syntaxfel, oväntat ";"
?>

Utan semikolon fungerar det bra:

foo(<<abcd
SLUTET
);
?>

3 år sedan

Du kan använda strängliknande array av char (som C)

$a = "String array test";

var_dump($a);
// Return string(17) "String array test"

var_dump($a);
// Return string(1) "S"

// -- Med array cast --
var_dump((array)$a);
// Return array(1) ( => string(17) "String array test")

var_dump((array)$a);
// Return string(17) "S"

Norihiori

1 år sedan

Varje enskilt uttryck, hur komplext det än är, som börjar med $ (dvs. en variabel) kan ()-bäddas in i en sträng med dubbla citattecken:

Echo "Uttrycket ( $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 )) blir tolkad lika bra som ". $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 ) . "gör." ;

?>

2 år sedan

Båda borde fungera :(

Klasstestning (
public static $VAR = "statisk" ;
public const VAR = "const" ;

offentlig funktion sayHelloStatic()(
echo "hej: ($this :: $VAR)" ;
}

public function sayHelloConst()(
echo "hello: ( $this ::VAR) " ; //Parse error: syntaxfel, oväntat ")", förväntar sig "["
}
}

$obj = ny testning();
$obj -> sayHelloStatic();
$obj -> sayHelloConst ();

14 år sedan

Du kan använda den komplexa syntaxen för att placera värdet för både objektegenskaper OCH objektmetoder i en sträng. Till exempel...
klasstesta{
offentlig$en= 1 ;
offentlig funktiontvå() {
lämna tillbaka2 ;
}
}
$test=nytesta();
eko"foo{ $test-> ett} bar{ $test-> två()} " ;
?>
Kommer att mata ut "foo 1 bar 2".

Du kan dock inte göra detta för alla värden i ditt namnområde. Klasskonstanter och statiska egenskaper/metoder kommer inte att fungera eftersom den komplexa syntaxen letar efter "$".
klasstesta{
konstETT= 1 ;
}
eko"foo (Test::ONE) bar";
?>
Detta kommer att mata ut "foo (Test::one) bar". Konstanter och statiska egenskaper kräver att du bryter upp strängen.

6 år sedan

Inledande nollor i strängar behandlas (minst överraskning) inte som oktala.
Överväga:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x är $x, y är $y"; //skriver ut "x är 123, y är 83"
med andra ord:
* inledande nollor i numeriska bokstaver i källkoden tolkas som "oktala", c.f. strtol().
* inledande nollor i strängar (t.ex. användarinlämnad data), när cast (implicit eller explicit) till heltal ignoreras och betraktas som decimal, c.f. strtod().

3 år sedan

Tänk på att i enlighet med "Strängkonvertering till siffror":

om ("123abc"== 123 ) eko"(intstr == int) testar felaktigt som sant.";

// Eftersom en sida är ett tal, konverteras strängen felaktigt från intstr till int, som sedan matchar testnumret.

// Sant för alla villkor som t.ex. if och switch-satser (förmodligen även while-loopar)!

// Detta kan vara en enorm säkerhetsrisk när man testar/använder/sparar användarinmatning, medan man förväntar sig och testar för endast ett heltal.

// Det verkar som att den enda fixen är att 123 är en sträng som "123" så ingen konvertering sker.

?>

10 år sedan

Här är ett enkelt hack för att tillåta strängar och heredocs med dubbla citattecken att innehålla godtyckliga uttryck i syntax med krulliga klammerparenteser, inklusive konstanter och andra funktionsanrop:

// Hack-deklaration
fungera_expr($v) (lämna tillbaka$v; }
$_expr= "_expr";

// Vår lekplats
definiera("qwe", "asd");
definiera("zxc", 5 );

$a= 3 ;
$b= 4 ;

fungera c($a, $b) (lämna tillbaka$a+ $b; }

// Användning
eko"före{ $_expr(1 + 2 )} post\n"; // matar ut "pre 3 post"
eko"före{ $_expr(qwe)} post\n"; // matar ut "pre asd post"
eko"före{ $_expr(c($a, $b)+ zxc* 2 )} post\n"; // matar ut "pre 17 post"

// Allmän syntax är ($_expr(...))
?>

11 år sedan

För att rädda ditt sinne, läs inte tidigare kommentarer om datum ;)

När båda strängarna kan konverteras till siffrorna (i ("$a" > "$b") test) används resulterande siffror, annars jämförs HELA strängar char-by-char:

var_dump("1.22" > "01.23" ); // bool(falskt)
var_dump("1.22.00" > "01.23.00" ); // bool(true)
var_dump("1-22-00" > "01-23-00" ); // bool(true)
var_dump((flyta)"1.22.00" > (flyta)"01.23.00" ); // bool(falskt)
?>

2 år sedan

Jag trodde att det skulle vara bra att lägga till denna kommentar så att informationen åtminstone visas på höger sida på PHP-webbplatsen.

Observera att om du tänker använda en sträng med dubbla citattecken med en associativ nyckel kan du stöta på T_ENCAPSED_AND_WHITESPACE-felet. Vissa ser detta som ett av de mindre uppenbara felmeddelandena.

Ett uttryck som:

$frukt=array(
"a"=> "äpple",
"b"=> banan,
//etc
);

skriva ut "Det här är en$frukt[ "a"]"; // T_ENCAPSED_AND_WHITESPACE
?>

kommer definitivt att falla i bitar.

Du kan lösa det på följande sätt:

skriva ut"Det här är en$frukt[ a] " ; // ta bort nyckeln
skriva ut"Det här är en${ frukter[ "a"]} " ; // Komplex syntax
skriva ut"Det här är en{ $frukt[ "a"]} " ; // Komplex syntaxvariation
?>

Jag har en personlig preferens för den sista varianten då den är mer naturlig och närmare hur uttrycket skulle vara utanför strängen.

Det är inte klart (åtminstone för mig) varför PHP misstolkar det enstaka citatet inuti uttrycket, men jag föreställer mig att det har något att göra med att citat inte är en del av värdesträngen - när strängen redan analyseras, citerar citaten bara komma i vägen … ?

Variabel $GLOBALS. En associativ array (array) som innehåller referenser till alla skriptets globala scope-variabler som för närvarande definieras. Variabelnamn är arraynycklar.

För att deklarera en global variabel räcker det att placera den i arrayen $GLOBALS

$GLOBALS["testkey2"]="testvärde2";

Du kan skriva ut alla värden för $GLOBALS-arrayvariablerna till skärmen med print_r($GLOBALS); eller så här:

Foreach ($GLOBALS som $key=>$value) eko "GLOBALS[".$key."] == ".$value."
";

Variabel $_SERVER.

Variabel $_REQUEST- en associativ array (array), som som standard innehåller data för variablerna $_GET, $_POST och $_COOKIE. Variabler i $_REQUEST-matrisen skickas till skriptet via metoderna GET, POST eller COOKIE, så de kan inte litas på eftersom de kan ha ändrats av en fjärranvändare. Deras närvaro och ordningen för att lägga till data till motsvarande arrayer bestäms av variables_order-direktivet (GPCS är inställt som standard).

Variabel $_SESSION

Variabel $_ENV. Fylls i om skriptet kördes från kommandoraden. $_SERVER-matrisen kommer att innehålla alla variabler från $_ENV-matrisen.

Variabel $http_response_header