Proměnné PHP je druh kontejneru s informacemi, který může obsahovat různé typy dat (text, čísla, pole atd.). Proměnné vám obecně umožňují vytvářet, ukládat, upravovat a v budoucnu rychle přistupovat k informacím v nich uvedeným.
Jak vytvořit proměnnou v PHP
Proměnné zpočátku obsahují znak $ (dolar) - označení použití proměnné, dále písmena latinka(od a do z a malé i velké), na konci může obsahovat čísla... Název také může používat podtržítko (ne na konci).Jak lze proměnné pojmenovat:
$ var
$ proměnná
$ rok1945
$ _ proměnné
Jak nelze volat proměnné:
$ 1 - skládá se pouze z číslice
$ 1var - název proměnné nelze začínat číslicí
$ / var - u dalších znaků jsou povolena pouze podtržítka _
$ variable - azbuka povolena dokumentací php, ale nedoporučuje se
$ var iable - mezery nelze použít
Každé proměnné je přiřazena hodnota. K přiřazení hodnoty použijte znaménko =
(rovná se). Během zpracování skriptu se může hodnota proměnné opakovaně měnit v závislosti na různých podmínkách.
$ city = "Moskva"; // proměnné $ city byla přiřazena hodnota řetězce (v uvozovkách) Moskva
$ rok = 1147; // a proměnné $ year byla přiřazena číselná hodnota 1147
?>
$ name = "Alexander";
$ Name = "Alexey";
echo "$ name, $ Name"; // zobrazí "Alexander, Alexey"
?>
Proměnný výstup PHP
Samostatně byste měli zvážit, jak zobrazit proměnné pomocí výstupní operátory, jehož práci jsme zkoumali v minulé lekci, Vytvoření stránky PHP. Operátory výstupu. ... Níže uvedu řadu názorných příkladů s komentáři.// Takto přiřadíme hodnoty proměnným
$ name1 = "Alexey";
$ name2 = "Alexander";
// Zobrazení proměnných
echo $ name2; // Výstup: Alexander
echo "name1 is $ name1"; // name1 je Alexey
// Při použití jednoduchých uvozovek je výstup
// název proměnné, nikoli hodnota
echo "name1 is $ name1"; // tiskne: name1 je $ name1
// můžete jednoduše zobrazit hodnoty proměnných
echo $ name1; // Alexey
echo $ name1, $ name2; // Alexey Alexander
echo $ name1. "". $ name2; // Alexey Alexander
echo "$ name1, $ name2"; // Alexey, Alexandre
Echo<<
více řádků s $ variabilní substitucí.
KONEC;
Variabilní operace PHP
Aritmetické operace v PHPV případě číselných hodnot můžete provádět aritmetické operace: sčítání, odčítání, násobení atd.
- $ a(negace) Změňte znak $ a.
$ a + $ b(navíc) Součet $ a a $ b.
$ a - $ b(odčítání) Rozdíl mezi $ a a $ b.
$ a * $ b(násobení) Součin $ a a $ b.
$ a / $ b(dělení) Podíl $ a dělený $ b.
$ a% $ b(modulo) Zbytek celého čísla $ a děleno $ b.
Podívejme se na příklady
$ a = 2; // poznámka, v případě čísel se uvozovky nepoužívají
$ b = 3; // poznámka, v případě čísel se uvozovky nepoužívají
$ result = $ a + $ b; // přidání proměnných
echo $ result; // vytiskne 5
$ result = $ b - $ a; // přidání proměnných
echo $ result; // vydá 1
Operace přírůstku a úbytku v PHP
Tyto operace budou užitečné hlavně při konstrukci smyček, o kterých si povíme o něco později.
Předpona- operátory napsané PŘED proměnnou ( - $ a; ++ $ a). Vrátí hodnotu proměnné před změnou.
Postfix- operátory zapsané za proměnnou ( $ a--; $ a--). Vrátí upravenou hodnotu proměnné.
Přírůstek- zvýšení hodnoty.
Snížení- snížení hodnoty.
++ $ a Přírůstek předpony. Zvýší $ a o jeden a vrátí $ a.
$ a ++ Přírůstek postfixu. Vrátí hodnotu $ a a poté zvýší $ a o jednu.
- $ a Snížení předpony. Sníží $ a o jednu a vrátí hodnotu $ a.
$ a-- Snížení postfixu. Vrátí hodnotu $ a a poté sníží $ a o jednu.
ozvěna "
Přírůstek postfixu
";$ a = 5;
echo „Mělo by být 5:“. $ a ++. "\ n";
Ozvěna "
Přírůstek předpony
";$ a = 5;
echo „Musí být 6:“. ++ $ a. "\ n";
echo „Musí být 6:“. $ a. "\ n";
Ozvěna "
Snížení postfixu
";$ a = 5;
echo „Mělo by být 5:“. $ a--. "\ n";
Ozvěna "
Snížení předpony
";$ a = 5;
echo „Mělo by být 4:“. - $ a. "\ n";
echo „Mělo by být 4:“. $ a. "\ n";
?>
Operace přiřazení PHP
Základní operátor vypadá jako =
... Na první pohled by se mohlo zdát, že tento operátor je rovnocenný. Ve skutečnosti tomu tak není. Ve skutečnosti operátor přiřazení znamená, že levý operand je nastaven na hodnotu pravého výrazu (tj. Nastaven výslednou hodnotou). Kombinované operátory- jedná se o operátory, které vám umožňují použít předchozí hodnoty proměnných pro následné operace (připojit k řetězcové proměnné (s textem) nebo přidat číselné hodnoty).
$ a = ($ b = 2) + 4; // výsledek: $ a je nastaveno na 6, $ b je nastaveno na 2.
$ a = 2;
$ a + = 3; // nastaví $ a na 5, podobně jako psaní: $ a = $ a + 3;
$ b = "Dobrý den";
$ b. = „Mír!“; // nastaví $ b na „Hello World!“ stejně jako $ b = $ b. "Tam!";
Jsou tu také srovnávací operace a hlavolam, ale o nich si povíme v dalších lekcích. Pokusím se vás hned nevystrašit velkým množstvím informací!)
Tato lekce zkoumá rozsah proměnných PHP. Vysvětluje rozdíl mezi místními a globálními obory, ukazuje, jak přistupovat ke globálním proměnným v rámci funkce, jak pracovat se superglobály a jak vytvářet statické proměnné.
Když se začnete učit PHP a začnete pracovat s funkcemi a objekty, rozsah proměnných je trochu matoucí. Naštěstí jsou pravidla PHP v tomto ohledu velmi snadno pochopitelná (ve srovnání s jinými programovacími jazyky).
Co je rozsah?
Rozsah proměnné je kontext, ve kterém byla proměnná definována a kde je k ní přístup. PHP má dva variabilní rozsahy:
- Globální- proměnné jsou přístupné kdekoli ve skriptu
- Místní- k proměnným lze přistupovat pouze uvnitř funkce, ve které byly definovány
Variabilní rozsah, a zejména místní rozsah, usnadňuje správu kódu. Pokud by všechny proměnné byly globální, mohly by být změněny kdekoli ve skriptu. To by vedlo k chaosu a velkým skriptům, protože velmi často různé části skriptu používají proměnné se stejným názvem. Rozsahem místního kontextu definujete hranice kódu, který může přistupovat k proměnné, čímž se kód stane robustnějším, modulárnějším a bude se snáze ladit.
Proměnné, které jsou globálně vymezeny, se označují jako globální a proměnné s místním rozsahem se nazývají místní.
Zde je příklad fungování globálních a lokálních proměnných.
";) sayHello (); echo" Hodnota \ $ globalName: "$ globalName"
"; echo" Hodnota \ $ localName: "$ localName"
";
?>
Ahoj Harry! $ GlobalName hodnota: "Zoe" $ localName hodnota: ""
V tomto skriptu jsme vytvořili dvě proměnné:
- $ globalName- tohle je globální proměnná
- $ localName- tohle je místní proměnná, která je vytvořena uvnitř funkce sayHello ().
Po vytvoření proměnné a funkce skript zavolá sayHello (), na jehož výstupu je „Hello Harry!“ ... Skript se poté pokusí zopakovat hodnoty těchto dvou proměnných. Co se děje:
- Protože $ globalName byl vytvořen mimo funkci, je k dispozici kdekoli ve skriptu, takže se zobrazí „Zoya“.
- $ localName bude k dispozici pouze uvnitř funkce sayHello (). Protože výraz echo je mimo funkci, PHP neumožňuje přístup k místní proměnné. Místo toho PHP předpokládá, že kód vytvoří novou proměnnou s názvem $ localName, která obdrží výchozí hodnotu prázdného řetězce. proto druhé volání echa vytiskne hodnotu "" pro proměnnou $ localName.
Přístup ke globálním proměnným uvnitř funkce
Pro přístup ke globální proměnné mimo provoz stačí napsat její jméno. Ale pro přístup ke globální proměnné vnitřní funkce, musíte nejprve deklarovat proměnnou jako globální ve funkci pomocí globálního klíčového slova:
Funkce myFunction () (global $ globalVariable; // Přístup ke globální proměnné $ globalVariable)
Pokud ne, PHP předpokládá, že vytváříte nebo používáte lokální proměnnou.
Zde je příklad skriptu, který používá globální proměnnou uvnitř funkce:
"; global $ globalName; echo" Dobrý den, $ globalName!
";) pozdravit ();?>
Po spuštění skript vydá:
Ahoj Harry! Ahoj Zoyo!
Funkce sayHello () používá globální klíčové slovo k deklaraci proměnné $ globalName jako globální. Poté může přistoupit k proměnné a zobrazit její hodnotu („Zoya“).
Co jsou to superglobals?
PHP má speciální sadu předdefinovaných globálních polí, která obsahují různé informace. Taková pole se nazývají superglobals, protože jsou přístupné odkudkoli ve skriptu, včetně vnitřního funkčního prostoru, a nemusí být definovány pomocí globálního klíčového slova.
Zde je seznam superglobálů dostupných v PHP 5.3:
- $ GLOBALS - seznam všech globálních proměnných ve skriptu (kromě superglobals)
- $ _GET - obsahuje seznam všech polí formuláře odeslaných prohlížečem pomocí požadavku GET
- $ _POST - obsahuje seznam všech polí formuláře odeslaných prohlížečem pomocí požadavku POST
- $ _COOKIE - obsahuje seznam všech cookies odeslaných prohlížečem
- $ _REQUEST - obsahuje všechny kombinace klíč / hodnota, které jsou obsaženy v polích $ _GET, $ _POST, $ _COOKIE
- $ _FILES - obsahuje seznam všech souborů načtených prohlížečem
- $ _SESSION - umožňuje ukládat a používat proměnné relace pro aktuální prohlížeč
- $ _SERVER - obsahuje informace o serveru, například název souboru prováděného skriptu a IP adresu prohlížeče.
- $ _ENV - Obsahuje seznam proměnných prostředí předaných do PHP, například proměnné CGI.
Pokud spustíte výše uvedený skript s řetězcem URL http://www.example.com/script.php?yourName=Fred, zobrazí se:
Ahoj Frede!
Varování! Ve skutečném skriptu byste nikdy neměli používat takový přenos dat kvůli slabému zabezpečení. Vždy byste měli zkontrolovat nebo filtrovat svá data.
Superglobal $ GLOBALS se velmi pohodlně používá, protože vám umožňuje organizovat přístup ke globálním proměnným ve funkci, aniž byste museli používat globální klíčové slovo. Například:
";) sayHello (); // Vytiskne" Ahoj, Zoe! "?>
Statické proměnné: jsou někde poblíž
Když vytvoříte místní proměnnou uvnitř funkce, existuje pouze tehdy, když je funkce spuštěna. Když funkce skončí, místní proměnná zmizí. Po opětovném volání funkce se vytvoří nová lokální proměnná.
Ve většině případů to funguje skvěle. Tímto způsobem jsou funkce samostatné a fungují vždy stejně při každém jejich volání.
Existují však situace, kdy by bylo vhodné vytvořit místní proměnnou, která si „pamatuje“ svou hodnotu mezi voláním funkcí. Taková proměnná se nazývá statická.
Chcete -li ve funkci vytvořit statickou proměnnou, musíte použít klíčové slovo static před názvem proměnné a ujistit se, že jí dáte počáteční hodnotu. Například:
Funkce myFunction () (static $ myVariable = 0;)
Uvažujme o situaci, kdy je vhodné použít statickou proměnnou. Řekněme, že vytvoříte funkci, která při volání vytvoří widget a zobrazí počet již vytvořených widgetů. Můžete zkusit napsat kód takto pomocí místní proměnné:
"; echo createWidget ()." již jsme vytvořili.
"; echo createWidget ()." již jsme vytvořili.>
";
?>
Ale protože proměnná $ numWidgets je vytvořena při každém volání funkce, dostaneme následující výsledek:
Vytváříme několik widgetů ... 1, které jsme již vytvořili. 1, které jsme již vytvořili. 1 jsme již vytvořili.
Ale pomocí statické proměnné můžeme uložit hodnotu z jednoho volání funkce do dalšího:
"; echo createWidget ()." již jsme vytvořili.
"; echo createWidget ()." již jsme vytvořili.
"; echo createWidget ()."> již jsme vytvořili.
";
?>
Skript nyní vytvoří očekávaný výstup:
Vytváříme několik widgetů ... 1, které jsme již vytvořili. 2, které jsme již vytvořili. 3, které jsme již vytvořili.
Přestože si statická proměnná zachovává svoji hodnotu mezi voláními funkcí, je platná pouze v okamžiku spuštění skriptu. Jakmile skript dokončí provádění, všechny statické proměnné jsou zničeny, stejně jako lokální a globální proměnné.
To je vše! Často kontrolujte dokumentaci PHP.
Proměnné prostředí (prostředí) ve Windows obsahují různé informace o nastavení systému a prostředí uživatele. Rozlišujte proměnné prostředí uživatele, systému a procesu.
Nejjednodušší způsob, jak zobrazit obsah proměnných prostředí v systému Windows, je otevřít vlastnosti systému ( sysdm.cpl) -> Pokročilé -> Proměnné prostředí. Jak vidíte, v otevřené sekci jsou dvě sekce: horní obsahuje proměnné prostředí uživatele, spodní obsahuje systémové.
Proměnné prostředí jsou navíc uloženy v systémovém registru. Vlastní proměnné jsou uloženy v sekci. Systém - v HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.
Hodnoty všech proměnných prostředí můžete zobrazit v příkazovém řádku systému Windows. Příkaz je jednoduchý:
Příkaz vypíše proměnné prostředí a jejich hodnoty.
V PowerShell můžete pomocí příkazu zobrazit všechny proměnné prostředí:
Pokud chcete zobrazit hodnotu pouze jedné proměnné, musíte použít příkaz echo a název proměnné musí být uzavřen v procentech. Například,
Echo% systemroot%
nastavit> c: \ tmp \ env_var.txt
Proměnné prostředí konkrétního procesu lze získat pomocí free Obslužné programy Process Explorer(od Sysinternals). Stačí otevřít vlastnosti procesu a přejít na kartu životní prostředí.
Před 13 lety
Trochu si musím dát pozor:
Pokud vypnete RegisterGlobals a související, pak použijete get_defined_vars (), můžete vidět něco jako následující:
Pole
[GLOBALS] => Pole
[GLOBALS] => Pole
* RECURZE *
[_POST] => Pole ()
[_GET] => Pole ()
[_COOKIE] => Pole ()
[_FILES] => Pole ()
)
[_POST] => Pole ()
[_GET] => Pole ()
[_COOKIE] => Pole ()
[_FILES] => Pole ()
)
?>
Všimněte si, že $ _SERVER tam není. Zdá se, že php načte superglobální $ _SERVER pouze tehdy, pokud je někde použit. Můžete to udělat takto:
tisk "
". htmlspecialchars (print_r (get_defined_vars (), true))."" ;
tisk "
". htmlspecialchars (print_r ($ _SERVER, true))."" ;
?>
A pak se $ _SERVER objeví v obou seznamech. Myslím, že to opravdu není gotcha, protože v žádném případě se nic zlého nestane, ale přesto je to zajímavá kuriozita.
před 6 lety
Vzhledem k tomu, že get_defined_vars () získá proměnné pouze v bodě, kterému tuto funkci zavoláte, existuje jednoduchý způsob, jak získat proměnné definované v aktuálním rozsahu.
// Úplný vrchol vašeho php skriptu
$ vars = get_defined_vars ();
// Nyní udělejte své věci
$ foo = "foo";
$ bar = "bar";
// Získejte všechny proměnné definované v aktuálním oboru
$ vars = array_diff (get_defined_vars (), $ vars);
ozvěna "
" ;" ;
print_r ($ vars);
ozvěna "
?>
před 15 lety
Zde je funkce, která generuje zprávu o ladění pro zobrazení nebo e -mail
pomocí get_defined_vars. Skvělé pro získání podrobného snímku bez
spoléhat se na vstup uživatele.
funkce generateDebugReport (metoda $, $ defined_vars, $ email = "undefined") (
// Funkce k vytvoření zprávy o ladění k zobrazení nebo odeslání e -mailem.
// Použití: generateDebugReport (metoda, get_defined_vars (), e -mail);
// Kde je metoda „prohlížeč“ nebo „e -mail“.
// Vytvořte seznam ignorovaných klíčů vrácených "get_defined_vars".
// Například HTTP_POST_VARS, HTTP_GET_VARS a další jsou
// nadbytečné (stejné jako _POST, _GET)
// Zahrňte také vars, které chcete z bezpečnostních důvodů ignorovat - tj. 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 = datum ("m / d / r h: m: s");
$ message = "Debug report created $ timestamp \ n";
// Získejte pro správnou míru poslední chybu SQL, kde $ link je identifikátor zdroje
// pro mysql_connect. Okomentujte nebo upravte nastavení databáze nebo abstrakce.
globální $ odkaz;
$ sql_error = mysql_error ($ link);
if ($ sql_error) (
$ message. = "\ nZprávy MySQL: \ n". mysql_error ($ link);
}
// Ukončení MySQL
// Zde lze použít rekurzivní funkci. Dostanete nápad ;-)
foreach ($ defined_vars jako $ key => $ val) (
if (is_array ($ val) &&! in_array ($ key, $ ignelist) && count ($ val)> 0) (
$ zpráva. = "\ n $ pole klíčů (klíč = hodnota): \ n";
foreach ($ val jako $ subkey => $ subval) (
if (! in_array ($ subkey, $ ignelist) &&! is_array ($ subval)) (
$ message. = $ podklíč. "=". $ subval. "\ n";
}
elseif (! in_array ($ subkey, $ ignorelist) && is_array ($ subval)) (
foreach ($ subval jako $ subsubkey => $ subsubval) (
if (! in_array ($ subsubkey, $ ignorelist)) (
$ message. = $ subsubkey. "=". $ subsubval. "\ n" ;
}
}
}
}
}
elseif (! is_array ($ val) &&! in_array ($ key, $ ignorelist) && $ val) (
$ message. = "\ nProměnná". $ klíč. "=". $ val. "\ n";
}
}
Pokud ($ method == "prohlížeč") (
echo nl2br ($ zpráva);
}
elseif ($ method == "email") (
if ($ email == "undefined") (
$ email = $ _SERVER ["SERVER_ADMIN"];
}
$ mresult = mail ($ email, "Debug Report for". $ _ENV ["HOSTNAME"]. "", $ message);
if ($ mresult == 1) (
echo "Zpráva o ladění byla úspěšně odeslána. \ N";
}
jinak (
echo "Nepodařilo se odeslat zprávu o ladění. \ N";
}
}
}
?>
Před 17 lety
Jednoduchá rutina pro převod objektu get_defined_vars na XML.
funkce obj2xml ($ v, $ indent = "") (
while (list ($ key, $ val) = each ($ v)) (
if ($ key == "__attr") pokračovat;
// Zkontrolovat __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)) (
tisk („$ odsazení<
$key$attr
>\ n ");
obj2xml ($ val, $ odsazení. "");
tisk („$ odsazení\ n ");
}
else print („$ odsazení<
$key$attr
>$ val\ n ");
}
}
// Příklad objektu
$ x -> jméno -> první = "John";
$ x -> jméno -> last = "Smith";
$ x -> arr ["Fruit"] = "Bannana";
$ x -> arr ["Veg"] = "Mrkev";
$ y -> zákazník = $ x;
$ y -> zákazník -> __attr -> id = "176C4";
$ z = get_defined_vars ();
obj2xml ($ z ["y"]);
?>
vydá:
Před 11 lety
Poznámka: get_defined_vars () nevrací sadu odkazů na proměnné (jak jsem doufal). Například:
// definujte proměnnou
$ my_var = "foo";
// získejte náš seznam definovaných proměnných
$ defined_vars = get_defined_vars ();
// nyní zkuste změnit hodnotu prostřednictvím vráceného pole
$ defined_vars ["my_var"] = "bar";
echo $ my_var, "\ n";
?>
vydá „foo“ (původní hodnota). Bylo by hezké, kdyby get_defined_vars () měl volitelný argument, který by jim dělal odkazy, ale já si představuji, že je to dost specializovaný požadavek. Můžete to udělat sami (méně pohodlně) s něčím jako:
$ defined_vars = pole ();
$ var_names = pole_klíče (get_defined_vars ());
foreach ($ var_names jako $ var_name)
{
$ defined_vars [$ var_name] = & $ $ var_name;
}
?>
před 1 rokem
Předtím jsem zde psal o tom, že „toto“ je v get_defined_vars.
Ukazuje se, že tam není vždy, ale v určitých případech se nevysvětlitelně objeví.
PHP -r "
test třídy (
veřejná funkce a () (var_dump (array_keys (get_defined_vars ())); $ a = 123;)
public function b () (var_dump (array_keys (get_defined_vars ())); $ this;)
}
$ t = nový test ();
$ t-> a ();
$ t-> b ();
"
Pole ()
pole („toto“)
To se nestane v PHP 7.2, ale stane se v PHP 5.6.
před 1 rokem
Některé komentáře zde poukazují na to, že tato funkce nevrací odkazy. Vrací však jména a názvy jsou „odkazy“.
Nedoporučoval bych zde návrhy, které by ji převáděly na reference.
Veřejná funkce x ($ a, $ b, $ c) (
foreach (array_keys (get_defined_vars ()) as $ key)
if ($ key! == "this")
$ this-> y ($ ($ klíč));
}
Veřejná funkce y (& $ vstup) (
$ vstup ++;
}
Místo $ () můžete také použít $$.
Udělal jsem ve své době pár nesmyslných věcí, abych vytvořil extrémně generický kód, ale nikdy jsem nemusel dělat nic jako výše. Možná to ani nebude fungovat (ale mělo by to být, protože se to nijak neliší od $ a [$ key]).
Můžete také použít $$ key ++, ale nikdy jsem neviděl takový kód, který by nebyl děsivě špatný (pomocí dynamického, kde dynamický není prospěšný).
Pokud něco takového děláte, proveďte další kontrolu.
