Php premenné je druh informačného kontajnera, ktorý môže obsahovať rôzne typy údajov (text, čísla, polia atď.). Premenné vám vo všeobecnosti umožňujú vytvárať, ukladať, upravovať a v budúcnosti rýchlo pristupovať k informáciám, ktoré sú v nich uvedené.

Ako vytvoriť premennú v PHP

Na začiatku premenné obsahujú znak $ (dolár) - označenie použitia premennej, potom písmen Latinská abeceda(od a do z a malé a veľké), na konci môže obsahovať čísla... Názov môže tiež používať podčiarkovník (nie na konci).

Ako môžete pomenovať premenné:

$ var
$ premenná
rok $ 1945
$ _ premenné
Ako nemožno premenné nazvať:

1 dolár - pozostáva iba z číslice
$ 1var - názov premennej nemôžete začať číslicou
$ / var - z ďalších znakov sú povolené iba podčiarkovníky _
$ variable - azbuka povolená dokumentáciou php, ale neodporúča sa
$ var iable - medzery nemožno použiť

Každej premennej je priradená hodnota. Na priradenie hodnoty použite znak = (rovná sa). Počas spracovania skriptu sa hodnota premennej môže opakovane meniť v závislosti od rôznych podmienok.

$ mesto = "Moskva"; // premennej $ city bola priradená hodnota reťazca (v úvodzovkách) Moskva
$ rok = 1147; // a premennej $ year bola priradená číselná hodnota 1147
?>

$ name = "Alexander";
$ Name = "Alexey";
echo "$ name, $ Name"; // zobrazuje "Alexander, Alexey"
?>

Variabilný výstup PHP

Samostatne by ste mali zvážiť, ako zobrazovať premenné pomocou výstupné operátory, o ktorej práci sme diskutovali v minulej lekcii, Vytvorenie stránky PHP. Operátory výstupu. ... Nasleduje niekoľko názorných príkladov s komentármi.

// Takto priradíme hodnoty premenným
$ name1 = "Alexey";
$ name2 = "Alexander";

// Zobrazenie premenných
echo $ name2; // Výstup: Alexander
echo "name1 is $ name1"; // meno1 je Alexey

// Pri použití jednoduchých úvodzoviek je výstup
// názov premennej, nie hodnota
echo "name1 is $ name1"; // prints: name1 je $ name1

// môžete len zobraziť hodnoty premenných
echo $ name1; // Alexey
echo $ name1, $ name2; // Alexey Alexander
echo $ name1. "". $ name2; // Alexey Alexander
echo "$ name1, $ name2"; // Alexey, Alexander

Ozvena<<Na výstup sa používa syntax „tu dokument“
viac riadkov s $ variabilnou substitúciou.
KONIEC;

Variabilné operácie PHP

Aritmetické operácie v PHP
V prípade číselných hodnôt môžete vykonávať aritmetické operácie: sčítanie, odčítanie, násobenie atď.

- $ a(negácia) Zmeňte znamienko $ a.
$ a + $ b(okrem) Suma $ a a $ b.
$ a - $ b(odčítanie) Rozdiel medzi $ a a $ b.
$ a * $ b(násobenie) Produkt súčinov $ a a $ b.
$ a / $ b(delenie) Podiel $ a delený $ b.
$ a% $ b(delenie modulo) Celý zvyšok $ a delený $ b.
Pozrime sa na príklady

$ a = 2; // poznámka, v prípade čísel sa úvodzovky nepoužívajú
$ b = 3; // poznámka, v prípade čísel sa úvodzovky nepoužívajú

$ výsledok = $ a + $ b; // pridanie premenných
echo $ result; // vytlačí 5

$ výsledok = $ b - $ a; // pridanie premenných
echo $ result; // vydá 1

Operácie prírastku a úbytku v PHP
Tieto operácie budú užitočné hlavne pri konštrukcii slučiek, o ktorých budeme hovoriť trochu neskôr.
Predpona- operátory napísané PRED premennou ( - $ a; ++ $ a). Vráti hodnotu premennej pred zmenou.
Postfix- operátory zapísané za premennou ( $ a--; $ a--). Vráti upravenú hodnotu premennej.
Prírastok- zvýšenie hodnoty.
Zníženie- zníženie hodnoty.

++ $ a Prírastok predpony. Zvýši $ a o jednu a vráti $ a.
$ a ++ Prírastok postfixu. Vráti hodnotu $ a a potom zvýši $ a o jednu.
- $ a Zníženie predpony. Zníži $ a o jednu a vráti hodnotu $ a.
$ a-- Zníženie postfixu. Vráti hodnotu $ a a potom zníži $ a o jednu.
ozvena "

Prírastok postfixu

";
$ a = 5;
echo „Malo by byť 5:“. $ a ++. "\ n";

Ozvena "

Prírastok predpony

";
$ a = 5;
echo „Malo by byť 6:“. ++ $ a. "\ n";
echo „Malo by byť 6:“. $ a. "\ n";

Ozvena "

Zníženie postfixu

";
$ a = 5;
echo „Malo by byť 5:“. $ a--. "\ n";

Ozvena "

Zníženie predpony

";
$ a = 5;
echo „Malo by byť 4:“. - $ a. "\ n";
echo „Malo by byť 4:“. $ a. "\ n";
?>

Operácie priradenia PHP
Základný operátor vyzerá ako = ... Na prvý pohľad sa môže zdať, že tento operátor je si rovný. V skutočnosti to tak nie je. V skutočnosti operátor priradenia znamená, že ľavému operandu je priradená hodnota pravého výrazu (t. J. Nastavená výslednou hodnotou). Kombinovaní operátori- sú to operátory, ktoré vám umožňujú použiť predchádzajúce hodnoty premenných na následné operácie (pripojiť k reťazcovej premennej (s textom) alebo pridať číselné hodnoty).

$ a = ($ b = 2) + 4; // výsledok: $ a je nastavený na 6, $ b je nastavený na 2.

$ a = 2;
$ a + = 3; // nastaví $ a na 5, podobne ako pri písaní: $ a = $ a + 3;
$ b = "ahoj";
$ b. = „Svet!“; // nastaví $ b na „Hello World!“ rovnako ako $ b = $ b. „Tam!“;

Existujú tiež porovnávacie operácie a hlavolam, ale o nich si povieme v nasledujúcich lekciách. Pokúsim sa vás hneď nevystrašiť veľkým množstvom informácií!)

Táto lekcia sa zaoberá rozsahom premenných PHP. Vysvetľuje rozdiel medzi miestnymi a globálnymi rozsahmi, ukazuje, ako pristupovať k globálnym premenným v rámci funkcie, ako pracovať so superglobálmi a ako vytvárať statické premenné.

Keď sa začnete učiť PHP a začnete pracovať s funkciami a objektmi, rozsah premenných je trochu mätúci. Našťastie sú pravidlá PHP v tomto ohľade veľmi ľahko zrozumiteľné (v porovnaní s inými programovacími jazykmi).

Čo je rozsah?

Rozsah premennej je kontext, v ktorom bola premenná definovaná a kde je k nej prístup. PHP má dva variabilné rozsahy:

• Globálne- k premenným je možné pristupovať kdekoľvek v skripte
• Miestne- k premenným je možné pristupovať iba vo vnútri funkcie, v ktorej boli definované

Variabilný rozsah, a najmä miestny rozsah, výrazne uľahčuje správu vášho kódu. Ak boli všetky premenné globálne, bolo ich možné zmeniť kdekoľvek v skripte. To by viedlo k chaosu a veľkým skriptom, pretože veľmi často rôzne časti skriptu používajú premenné s rovnakým názvom. Rozsahom lokálneho kontextu definujete hranice kódu, ktorý má prístup k premennej, čím sa kód stane robustnejším, modulárnejším a ľahšie sa ladí.

Proměnné s globálnym rozsahom sa nazývajú globálne a tie s lokálnym rozsahom sa nazývajú lokálne.

Tu je príklad toho, ako fungujú globálne a lokálne premenné.

";) sayHello (); echo" Hodnota \ $ globalName: "$ globalName"
"; echo" Hodnota \ $ localName: "$ localName"
"; ?>

Ahoj Harry! $ GlobalName hodnota: "Zoe" $ localName hodnota: ""

V tomto skripte sme vytvorili dve premenné:

• $ globalName- toto je globálny premenná
• $ localName- toto je miestny premenná, ktorá je vytvorená vo funkcii sayHello ().

Po vytvorení premennej a funkcie skript zavolá sayHello (), z ktorého sa zobrazí „Hello Harry!“ ... Skript sa potom pokúsi zopakovať hodnoty týchto dvoch premenných. Čo sa deje:

• Pretože $ globalName bol vytvorený mimo funkcie, je k dispozícii kdekoľvek v skripte, takže sa zobrazuje "Zoya".
• $ localName bude k dispozícii iba vo funkcii sayHello (). Pretože výraz ozveny je mimo funkcie, PHP neumožňuje prístup k lokálnej premennej. Namiesto toho PHP predpokladá, že kód vytvorí novú premennú s názvom $ localName, ktorá dostane predvolenú hodnotu prázdneho reťazca. preto druhé volanie echa vytlačí hodnotu "" pre premennú $ localName.

Prístup k globálnym premenným vo funkcii

Prístup k globálnej premennej mimo funkcie stačí napísať jej meno. Ale prístup k globálnej premennej vnútorná funkcia, musíte vo funkcii najskôr premennú vyhlásiť za globálnu pomocou globálneho kľúčového slova:

Funkcia myFunction () (global $ globalVariable; // Prístup ku globálnej premennej $ globalVariable)

Ak nie, PHP predpokladá, že vytvárate alebo používate lokálnu premennú.

Tu je príklad skriptu, ktorý vo funkcii používa globálnu premennú:

"; global $ globalName; echo" Dobrý deň, $ globalName!
";) pozdraviť ();?>

Po spustení skript zobrazí:

Ahoj Harry! Ahoj Zoya!

Funkcia sayHello () používa globálne kľúčové slovo na deklarovanie premennej $ globalName ako globálnej. Potom môže získať prístup k premennej a zobraziť jej hodnotu („Zoya“).

Čo sú to superglobály?

PHP má špeciálnu sadu preddefinovaných globálnych polí, ktoré obsahujú rôzne informácie. Takéto polia sa nazývajú superglobály, pretože sú dostupné odkiaľkoľvek v skripte vrátane vnútorného priestoru funkcií a nie je ich potrebné definovať pomocou globálneho kľúčového slova.

Tu je zoznam superglobálov dostupných v PHP 5.3:

• $ GLOBALS - zoznam všetkých globálnych premenných v skripte (okrem superglobálov)
• $ _GET - obsahuje zoznam všetkých polí formulára odoslaných prehliadačom pomocou požiadavky GET
• $ _POST - obsahuje zoznam všetkých polí formulára odoslaných prehliadačom pomocou požiadavky POST
• $ _COOKIE - obsahuje zoznam všetkých súborov cookie odoslaných prehliadačom
• $ _REQUEST - obsahuje všetky kombinácie kľúč / hodnota, ktoré sú obsiahnuté v poliach $ _GET, $ _POST, $ _COOKIE
• $ _FILES - obsahuje zoznam všetkých súborov načítaných prehliadačom
• $ _SESSION - umožňuje ukladať a používať premenné relácie pre aktuálny prehliadač
• $ _SERVER - obsahuje informácie o serveri, ako napríklad názov spusteného skriptu a IP adresa prehliadača.
• $ _ENV - obsahuje zoznam premenných prostredia odovzdaných do PHP, napríklad premenných CGI.

$ _GET môžete napríklad použiť na získanie hodnôt premenných uzavretých v reťazci adresy URL žiadosti o skript a ich zobrazenie na stránke:

Ak spustíte vyššie uvedený skript s reťazcom adresy URL http://www.example.com/script.php?yourName=Fred, výsledkom bude:

Ahoj Fred!

Varovanie! V skutočnom skripte by ste takýto prenos údajov nikdy nemali používať kvôli slabému zabezpečeniu. Údaje by ste mali vždy skontrolovať alebo filtrovať.

Superglobal $ GLOBALS je veľmi pohodlný na používanie, pretože vám umožňuje organizovať prístup ku globálnym premenným vo funkcii bez toho, aby ste museli používať globálne kľúčové slovo. Napríklad:

";) sayHello (); // Výstupy" Ahoj, Zoe! "?>

Statické premenné: sú niekde v blízkosti

Keď vytvoríte lokálnu premennú vo funkcii, existuje iba vtedy, keď je funkcia spustená. Keď sa funkcia skončí, lokálna premenná zmizne. Keď sa funkcia znova zavolá, vytvorí sa nová lokálna premenná.

Vo väčšine prípadov to funguje skvele. Vďaka tomu sú funkcie samostatné a vždy fungujú rovnako pri každom volaní.

Existujú však situácie, kedy by bolo vhodné vytvoriť lokálnu premennú, ktorá si medzi volaniami funkcií „pamätá“ svoju hodnotu. Takáto premenná sa nazýva statická.

Na vytvorenie statickej premennej vo funkcii musíte použiť statické kľúčové slovo pred názvom premennej a dať jej počiatočnú hodnotu. Napríklad:

Funkcia myFunction () (static $ myVariable = 0;)

Uvažujme o situácii, keď je vhodné použiť statickú premennú. Povedzme, že vytvoríte funkciu, ktorá po zavolaní vytvorí miniaplikáciu a zobrazí počet už vytvorených miniaplikácií. Môžete skúsiť napísať kód takto pomocou lokálnej premennej:

„; echo createWidget ().“ už sme vytvorili.
„; echo createWidget ().“ už sme vytvorili.>
"; ?>

Pretože však premenná $ numWidgets je vytvorená pri každom volaní funkcie, dostaneme nasledujúci výsledok:

Vytvárame niekoľko miniaplikácií ... 1, ktoré sme už vytvorili. 1, ktoré sme už vytvorili. 1, ktoré sme už vytvorili.

Ale pomocou statickej premennej môžeme uložiť hodnotu z jedného volania funkcie do nasledujúceho:

„; echo createWidget ().“ už sme vytvorili.
„; echo createWidget ().“ už sme vytvorili.
"; echo createWidget ()."> už sme vytvorili.
"; ?>

Skript teraz vytvorí očakávaný výstup:

Vytvárame niekoľko miniaplikácií ... 1, ktoré sme už vytvorili. 2, ktoré sme už vytvorili. 3, ktoré sme už vytvorili.

Aj keď si statická premenná zachováva svoju hodnotu medzi volaniami funkcií, je platná iba v čase spustenia skriptu. Hneď ako skript dokončí svoje vykonávanie, všetky statické premenné, ako aj lokálne a globálne premenné sú zničené.

To je všetko! Často kontrolujte dokumentáciu PHP.

Premenné prostredia (prostredie) v systéme Windows obsahujú rôzne informácie o systémových nastaveniach a prostredí používateľa. Rozlišujte medzi premennými prostredia používateľa, systému a procesu.

Najjednoduchším spôsobom, ako zobraziť obsah premenných prostredia v systéme Windows, je otvoriť vlastnosti systému ( sysdm.cpl) -> Rozšírené -> Premenné prostredia. Ako vidíte, v otvorenej sekcii sú dve sekcie: horná obsahuje premenné prostredia používateľa, dolná obsahuje systémové.

Premenné prostredia sú navyše uložené v systémovom registri. Vlastné premenné sú uložené v sekcii. Systém - v HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

Hodnoty všetkých premenných prostredia môžete zobraziť v príkazovom riadku systému Windows. Príkaz je jednoduchý:

Príkaz vypíše premenné prostredia a ich hodnoty.

V PowerShell môžete použiť príkaz na zobrazenie všetkých premenných prostredia:

Ak chcete zobraziť hodnotu iba jednej premennej, musíte použiť príkaz echo a názov premennej musí byť uzavretý v percentách. Napríklad,

Echo% systemroot%

nastaviť> c: \ tmp \ env_var.txt

Premenné prostredia konkrétneho procesu je možné získať pomocou bezplatného programu Pomôcky Process Explorer(od Sysinternals). Stačí otvoriť vlastnosti procesu a prejsť na kartu Životné prostredie.

Pred 13 rokmi

Trochu si treba dať pozor:

Ak vypnete RegisterGlobals a súvisiace, potom použijete get_defined_vars (), môže sa vám zobraziť niečo podobné nasledujúcemu:

Array
[GLOBALS] => Pole
[GLOBALS] => Pole
* RECURZIA *
[_POST] => Pole ()
[_GET] => Pole ()
[_COOKIE] => Pole ()
[_FILES] => Pole ()
)

[_POST] => Pole ()
[_GET] => Pole ()
[_COOKIE] => Pole ()
[_FILES] => Pole ()

)
?>

Všimnite si, že $ _SERVER tam nie je. Zdá sa, že php načíta superglobálny $ _SERVER iba vtedy, ak je niekde použitý. Môžete to urobiť takto:

vytlačiť "

". htmlspecialchars (print_r (get_defined_vars (), true))."

" ;
vytlačiť "

". htmlspecialchars (print_r ($ _SERVER, true))."

" ;
?>

A potom sa $ _SERVER objaví v oboch zoznamoch. Myslím, že to nie je žiadna hádka, pretože v každom prípade sa nič zlé nestane, ale napriek tomu je to zaujímavá kuriozita.

Pred 6 rokmi

Pretože get_defined_vars () získa premenné iba v mieste, ktoré nazývate funkciou, existuje jednoduchý spôsob, ako premenné definovať v aktuálnom rozsahu.

// Úplný vrchol vášho skriptu php
$ vars = get_defined_vars ();

// Teraz si urobte svoje veci
$ foo = "foo";
$ bar = "bar";

// Získajte všetky premenné definované v aktuálnom rozsahu
$ vars = rozdiel_pole (get_defined_vars (), $ vars);

ozvena "

"
;
print_r ($ vars); 
ozvena "

" ;
?>

Pred 15 rokmi

Tu je funkcia, ktorá generuje správu o ladení pre zobrazenie alebo e -mail
pomocou get_defined_vars. Skvelé na získanie podrobnej snímky bez
spoliehať sa na vstupy používateľov.

funkcia generateDebugReport (metóda $, $ defined_vars, $ email = "nedefinované") (
// Funkcia na vytvorenie správy o ladení na zobrazenie alebo odoslanie e -mailom.
// Použitie: generateDebugReport (metóda, get_defined_vars (), e -mail);
// Kde je metóda „prehliadač“ alebo „e -mail“.

// Vytvorte zoznam ignorovaných kľúčov vrátených reťazcom „get_defined_vars“.
// Napríklad HTTP_POST_VARS, HTTP_GET_VARS a ďalšie sú
// nadbytočné (rovnaké ako _POST, _GET)
// Zahrňte aj vars, ktoré chcete z bezpečnostných dôvodov ignorovať - ​​t.j. PHPSESSID.
$ ignorelist = pole ("HTTP_POST_VARS", "HTTP_GET_VARS",
"HTTP_COOKIE_VARS", "HTTP_SERVER_VARS",
"HTTP_ENV_VARS", "HTTP_SESSION_VARS",
„_ENV“, „PHPSESSID“, „SESS_DBUSER“,
„SESS_DBPASS“, „HTTP_COOKIE“);

$ timestamp = dátum ("m / d / r h: m: s");
$ message = "Správa o ladení vytvorená $ timestamp \ n";

// Pre istotu získajte poslednú chybu SQL, kde $ link je identifikátor zdroja
// pre mysql_connect. Komentujte alebo upravte svoje nastavenia databázy alebo abstrakcie.
globálny odkaz $;
$ sql_error = mysql_error ($ link);
if ($ sql_error) (
$ message. = "\ nMoje správy: \ n". mysql_error ($ link);
}
// Ukončite MySQL

// Tu by sa dala použiť rekurzívna funkcia. Rozumiete si ;-)
foreach ($ defined_vars ako $ key => $ val) (
if (is_array ($ val) &&! in_array ($ key, $ ignelist) && count ($ val)> 0) (
$ správa. = "\ n $ pole kľúčov (kľúč = hodnota): \ n";
foreach ($ val ako $ subkey => $ subval) (
if (! in_array ($ subkey, $ ignorelist) &&! is_array ($ subval)) (
$ message. = $ podkľúč. "=". $ subval. "\ n";
}
elseif (! in_array ($ subkey, $ ignorelist) && is_array ($ subval)) (
foreach ($ subval ako $ subsubkey => $ subsubval) (
if (! in_array ($ subsubkey, $ ignorelist)) (
$ message. = $ subsubkey. "=". $ sububval. "\ n" ;
}
}
}
}
}
ináč Ak (! is_array ($ val) &&! in_array ($ key, $ ignorelist) && $ val) (
$ message. = "\ nVariabilné". $ kľúč. "=". $ val. "\ n";
}
}

Ak ($ method == "prehliadač") (
echo nl2br ($ správa);
}
elseif ($ method == "email") (
if ($ email == "undefined") (
$ email = $ _SERVER ["SERVER_ADMIN"];
}

$ mresult = mail ($ email, "Správa o ladení pre". $ _ENV ["HOSTNAME"]. "", $ správa);
if ($ mresult == 1) (
ozvena "Správa o ladení bola úspešne odoslaná. \ N";
}
inak (
ozvena "Nepodarilo sa odoslať správu o ladení. \ N";
}
}
}
?>

Pred 17 rokmi

Jednoduchá rutina na konverziu objektu get_defined_vars na XML.

funkcia obj2xml ($ v, $ indent = "") (
while (list ($ key, $ val) = each ($ v)) (
if ($ key == "__attr") pokračovať;
// Vyhľadajte __attr
if (is_object ($ val -> __attr)) (
while (list ($ key2, $ val2) = each ($ val -> __attr)) (
$ attr. = "$ key2 = \" $ val2 \ "";
}
}
else $ attr = "";
if (is_array ($ val) || is_object ($ val)) (
tlač („$ odsadenie< $key$attr >\ n ");
obj2xml ($ val, $ zarážka. "");
tlač („$ odsadenie\ n ");
}
else print („$ odsadenie< $key$attr >$ val\ n ");
}
}

// Príklad objektu
$ x -> meno -> prvé = "John";
$ x -> meno -> priezvisko = "Smith";
$ x -> arr ["Ovocie"] = "Bannana";
$ x -> arr ["Veg"] = "Mrkva";
$ y -> zákazník = $ x;
$ y -> zákazník -> __attr -> id = "176C4";

$ z = get_defined_vars ();
obj2xml ($ z ["y"]);
?>
vydá:


John
Smith


Banán
Mrkva

Pred 11 rokmi

Poznámka: get_defined_vars () nevracia množinu odkazov na premenné (ako som dúfal). Napríklad:

// definujte premennú
$ my_var = "foo";

// získajte náš zoznam definovaných premenných
$ defined_vars = get_defined_vars ();

// teraz skúste zmeniť hodnotu prostredníctvom vráteného poľa
$ defined_vars ["my_var"] = "bar";

echo $ my_var, "\ n";

?>

zobrazí "foo" (pôvodná hodnota). Bolo by pekné, keby get_defined_vars () mal voliteľný argument, ktorý by z nich robil referencie, ale ja si predstavujem, že je to dosť špecializovaná požiadavka. Môžete to urobiť sami (menej pohodlne) s niečím ako:

$ definovane_vars = pole ();
$ var_names = kľúče poľa (get_defined_vars ());

foreach ($ var_names ako $ var_name)
{
$ defined_vars [$ var_name] = & $ $ var_name;
}

?>

Pred 1 rokom

Predtým som tu písal o tom, že „toto“ je v súboroch get_defined_vars.

Ukazuje sa, že to nie je vždy tam, ale v určitých prípadoch sa to nevysvetliteľne objaví.

PHP -r "
triedny test (
verejná funkcia a () (var_dump (array_keys (get_defined_vars ())); $ a = 123;)
verejná funkcia b () (var_dump (array_keys (get_defined_vars ())); $ this;)
}
$ t = nový test ();
$ t-> a ();
$ t-> b ();
"

Pole ()
pole („toto“)

To sa nestane v PHP 7.2, ale stane sa v PHP 5.6.

Pred 1 rokom

Niektoré komentáre tu poukazujú na to, že táto funkcia nevracia referencie. Vracia však mená a názvy sú „referencie“.

Neodporúčal by som tu uvedené návrhy, ktoré by ho prevádzali na referencie.

Verejná funkcia x ($ a, $ b, $ c) (
foreach (array_keys (get_defined_vars ()) as $ key)
if ($ key! == "this")
$ this-> y ($ ($ kľúč));
}

Verejná funkcia y (& $ vstup) (
$ vstup ++;
}

Namiesto $ () môžete použiť aj $$.

Vo svojej dobe som urobil niekoľko šialených vecí, aby som vytvoril extrémne generický kód, ale nikdy som nemusel urobiť nič také, ako je uvedené vyššie. Možno to ani nebude fungovať (ale malo by, pretože sa to nelíši od $ a [$ key]).

Môžete tiež urobiť $$ key ++, ale nikdy som nevidel taký kód, ktorý by nebol strašne zlý (pomocou dynamického, kde dynamický nie je prospešný).

Ak niečo také robíte, dajte mu ďalšie preskúmanie.