Variabile PHP este un fel de container de informații care poate conține diverse tipuri de date (text, numere, matrice și așa mai departe). În general, variabilele vă permit să creați, să stocați, să modificați și, în viitor, să accesați rapid informațiile specificate în ele.

Cum se creează o variabilă în PHP

Inițial, variabilele conțin semnul $ (dolar) - desemnarea utilizării unei variabile, apoi litere alfabet latin(de la a la z și mic și mare), la sfârșit poate conține numere... De asemenea, numele poate folosi un caracter de subliniere (nu la sfârșit).

Cum puteți numi variabile:

$ var
$ variabilă
Anul $1945
$ _variabilă
Cum variabilele nu pot fi numite:

$ 1 - este format doar dintr-o cifră
$ 1var - nu puteți începe un nume de variabilă cu o cifră
$ / var - sunt permise doar caractere suplimentare _
$ variabilă - Chirilic permis de documentația php, dar nu este recomandat
$ var iable - spațiile nu pot fi folosite

Fiecărei variabile i se atribuie o valoare. Pentru a atribui o valoare, utilizați semnul = (egal). În timpul procesării scriptului, valoarea variabilei se poate schimba în mod repetat în funcție de diferite condiții.

$ oraș = „Moscova”; // variabilei $ oraș i s-a atribuit un șir (între ghilimele) valoare Moscova
$ an = 1147; // și variabilei $ an i s-a atribuit valoarea numerică 1147
?>

$ nume = "Alexander";
$ Nume = "Alexey";
echo „$ nume, $ Nume”; // afișează „Alexander, Alexey”
?>

Ieșire variabilă PHP

Separat, ar trebui să luați în considerare modul de afișare a variabilelor folosind operatori de ieşire, despre care am discutat în ultima lecție, Crearea unei pagini PHP. Operatori de ieșire. ... Mai jos sunt câteva exemple ilustrative cu comentarii.

// Așa atribuim valori variabilelor
$ name1 = "Alexey";
$ name2 = "Alexander";

// Afișează variabile
echo $ nume2; // Ieșire: Alexandru
echo "nume1 este $ nume1"; // numele 1 este Alexey

// Când folosiți ghilimele simple, rezultatul este
// nume variabilă, nu valoare
echo "nume1 este $ nume1"; // afișează: nume1 este $ nume1

// puteți afișa doar valorile variabilelor
echo $ nume1; // Alexey
echo $ nume1, $ nume2; // Alexey Alexander
echo $ nume1. "". $ nume2; // Alexey Alexander
echo „$ nume1, $ nume2”; // Alexey, Alexandru

Ecou<<Aceasta folosește sintaxa „aici document” pentru ieșire
linii multiple cu $ substituție variabilă.
SFÂRȘIT;

Operații cu variabile PHP

Operații aritmetice în PHP
În cazul valorilor numerice, puteți efectua operații aritmetice: adunare, scădere, înmulțire etc.

- $ a(negație) Schimbați semnul $ a.
$ a + $ b(adăugare) Suma $ a și $ b.
$ a - $ b(scădere) Diferența dintre $ a și $ b.
$ a * $ b(înmulțire) Produsul lui $ a și $ b.
$ a / $ b(diviziunea) Coeficientul $ a împărțit la $ b.
$ a% $ b(modulo) Restul întreg al lui $ a împărțit la $ b.
Să ne uităm la exemple

$ a = 2; // notează, în cazul numerelor nu se folosesc ghilimele
$ b = 3; // notează, în cazul numerelor nu se folosesc ghilimele

$ rezultat = $ a + $ b; // adaugă variabile
echo $ rezultat; // va tipări 5

$ rezultat = $ b - $ a; // adaugă variabile
echo $ rezultat; // va scoate 1

Operații de creștere și decrementare în PHP
Aceste operații vor fi utile în principal la construirea buclelor, despre care vom vorbi puțin mai târziu.
Prefix- operatori scrii ÎNAINTE de variabilă ( - $ a; ++ $ a). Returnează valoarea variabilei înainte de modificare.
Postfix- operatori scrisi dupa variabila ( $ a--; $ a--). Returnează valoarea modificată a variabilei.
Creştere- cresterea valorii.
Decrementează- scăderea valorii.

++ $ a Creșterea prefixului. Crește $ a cu unul și returnează $ a.
$ a ++ Creștere postfix. Returnează valoarea $ a și apoi incrementează $ a cu unul.
- $ a Decrementarea prefixului. Descrește $ a cu unu și returnează valoarea $ a.
$ a-- Scădere postfix. Returnează valoarea lui $ a și apoi decrește $ a cu unul.
ecou"

Creștere postfix

";
$ a = 5;
ecou „Ar trebui să fie 5:”. $ a ++. „\ n”;

Ecou"

Creșterea prefixului

";
$ a = 5;
ecou „Ar trebui să fie 6:”. ++ $ a. „\ n”;
ecou „Ar trebui să fie 6:”. $ a. „\ n”;

Ecou"

Scădere postfix

";
$ a = 5;
ecou „Ar trebui să fie 5:”. $ a--. „\ n”;

Ecou"

Decrementarea prefixului

";
$ a = 5;
ecou „Ar trebui să fie 4:”. - $ a. „\ n”;
ecou „Ar trebui să fie 4:”. $ a. „\ n”;
?>

Operații de atribuire PHP
Operator de bază se pare ca = ... La prima vedere, poate părea că acest operator este egal. De fapt, acesta nu este cazul. De fapt, operatorul de atribuire înseamnă că operandul din stânga este setat la valoarea expresiei din dreapta, (adică, setat de valoarea rezultată). Operatori combinați- aceștia sunt operatori care vă permit să utilizați valorile anterioare ale variabilelor pentru operațiuni ulterioare (adăugați la o variabilă șir (cu text) sau adăugați valori numerice).

$ a = ($ b = 2) + 4; // rezultat: $ a este setat la 6, $ b este setat la 2.

$ a = 2;
$ a + = 3; // setează $ a la 5, similar cu scrierea: $ a = $ a + 3;
$ b = „Bună ziua”;
$ b. = „Pace!”; // setează $ b la „Bună lume!” la fel ca $ b = $ b. "Acolo!";

Există, de asemenea operatii de comparatieși joc de inteligență, dar despre ele vom vorbi în lecțiile următoare. Voi încerca să nu vă sperii cu o cantitate mare de informații imediat!)

Această lecție explorează domeniul de aplicare al variabilelor PHP. Explică diferența dintre domeniile locale și globale, arată cum să accesezi variabile globale într-o funcție, cum să lucrezi cu superglobale și cum să creezi variabile statice.

Când începeți să învățați PHP și începeți să lucrați cu funcții și obiecte, domeniul de aplicare al variabilelor este puțin confuz. Din fericire, regulile PHP în acest sens sunt foarte ușor de înțeles (comparativ cu alte limbaje de programare).

Ce este domeniul de aplicare?

Domeniul de aplicare al variabilei este contextul în care a fost definită o variabilă și unde poate fi accesată. PHP are două domenii variabile:

• Globalul- variabilele pot fi accesate oriunde în script
• Local- variabilele pot fi accesate numai în interiorul funcției în care au fost definite

Domeniul de aplicare variabil, și în special domeniul de aplicare local, facilitează gestionarea codului. Dacă toate variabilele ar fi globale, atunci ele ar putea fi modificate oriunde în script. Acest lucru ar duce la haos și la scripturi mari, deoarece foarte adesea părți diferite ale scriptului folosesc variabile cu același nume. Prin definirea contextului local, definiți limitele codului care poate accesa variabila, făcând codul mai robust, modular și mai ușor de depanat.

Se spune că variabilele care au un scop global sunt globale, iar variabilele cu domeniu local sunt numite locale.

Iată un exemplu despre cum funcționează variabilele globale și locale.

";) sayHello (); echo" Valoare \ $ globalName: "$ globalName"
„; echo” Valoare \ $ localName: „$ localName”
"; ?>

Salut Harry! Valoare $ GlobalName: „Zoe” Valoare $ localName: „”

În acest script, am creat două variabile:

• $ globalName- aceasta este o globală variabil
• $ localName- aceasta este local o variabilă care este creată în interiorul funcției sayHello ().

După crearea variabilei și a funcției, scriptul apelează sayHello (), care scoate „Hello Harry!” ... Scriptul încearcă apoi să ecou valorile celor două variabile. Iată ce se întâmplă:

• pentru că $ globalName a fost creat în afara funcției, este disponibil oriunde în script, așa că este afișat „Zoya”.
• $ localName va fi disponibil numai în cadrul funcției sayHello (). Deoarece expresia ecou este în afara funcției, PHP nu permite accesul la variabila locală. În schimb, PHP presupune că codul va crea o nouă variabilă numită $ localName, care va primi o valoare implicită a unui șir gol. acesta este motivul pentru care al doilea apel la echo tipărește valoarea „” pentru variabila $ localName.

Accesarea variabilelor globale în interiorul unei funcții

Pentru a accesa o variabilă globală in afara functiei scrie doar numele ei. Dar pentru a accesa variabila globală funcție interioară, mai întâi trebuie să declarați variabila ca globală în funcție folosind cuvântul cheie global:

Funcția myFunction () (global $ globalVariable; // Acces la variabila globală $ globalVariable)

Dacă nu, PHP presupune că creați sau utilizați o variabilă locală.

Iată un exemplu de script care utilizează o variabilă globală în interiorul unei funcții:

"; global $ globalName; echo" Bună ziua $ globalName!
„;) spune Bună ();?>

Când este executat, scriptul va afișa:

Salut Harry! Salut Zoya!

Funcția sayHello () folosește cuvântul cheie global pentru a declara variabila $ globalName ca globală. Apoi ea poate accesa variabila și poate afișa valoarea acesteia ("Zoya").

Ce sunt superglobalii?

PHP are un set special de matrice globale predefinite care conțin diverse informații. Astfel de matrice sunt numite superglobali, deoarece sunt accesibile de oriunde în script, inclusiv din spațiul interior al funcției, și nu trebuie să fie definite folosind cuvântul cheie global.

Iată o listă de superglobali disponibile în PHP 5.3:

• $ GLOBALS - listă cu toate variabilele globale din script (cu excepția superglobalelor)
• $ _GET - Conține o listă a tuturor câmpurilor de formular trimise de browser folosind o solicitare GET
• $ _POST - conține o listă a tuturor câmpurilor de formular trimise de browser folosind o solicitare POST
• $ _COOKIE - conține o listă cu toate modulele cookie trimise de browser
• $ _REQUEST - conține toate combinațiile cheie/valoare care sunt conținute în tablourile $ _GET, $ _POST, $ _COOKIE
• $ _FILES - conține o listă cu toate fișierele încărcate de browser
• $ _SESSION - vă permite să stocați și să utilizați variabile de sesiune pentru browserul curent
• $ _SERVER - conține informații despre server, cum ar fi numele fișierului scriptului care se execută și adresa IP a browserului.
• $ _ENV - Conține o listă de variabile de mediu transmise PHP, de exemplu variabile CGI.

De exemplu, puteți utiliza $ _GET pentru a obține valorile variabilelor incluse în șirul URL al solicitării de script și pentru a le afișa pe pagină:

Dacă rulați scriptul de mai sus cu șirul URL http://www.example.com/script.php?yourName=Fred, va afișa:

Salut Fred!

Un avertisment!Într-un script real, nu ar trebui să utilizați niciodată un astfel de transfer de date din cauza securității slabe. Ar trebui să vă verificați sau să filtrați întotdeauna datele.

Superglobalul $ GLOBALS este foarte convenabil de utilizat deoarece vă permite să organizați accesul la variabilele globale într-o funcție fără a fi nevoie să utilizați cuvântul cheie global. De exemplu:

„;) sayHello (); // Afișează „Bună ziua, Zoe! „?>

Variabile statice: sunt undeva în apropiere

Când creați o variabilă locală în interiorul unei funcții, aceasta există doar în timp ce funcția rulează. Când funcția se termină, variabila locală dispare. Când funcția este apelată din nou, este creată o nouă variabilă locală.

Acest lucru funcționează excelent în majoritatea cazurilor. În acest fel, funcțiile sunt autonome și funcționează întotdeauna la fel de fiecare dată când sunt apelate.

Cu toate acestea, există situații în care ar fi convenabil să se creeze o variabilă locală care „își amintește” valoarea între apelurile de funcții. O astfel de variabilă se numește static.

Pentru a crea o variabilă statică într-o funcție, trebuie să utilizați cuvântul cheie static în fața numelui variabilei și asigurați-vă că îi dați o valoare inițială. De exemplu:

Funcția myFunction () (static $ myVariable = 0;)

Să luăm în considerare o situație în care este convenabil să folosiți o variabilă statică. Să presupunem că creați o funcție care, atunci când este apelată, creează un widget și afișează numărul de widget-uri deja create. Puteți încerca să scrieți cod ca acesta folosind o variabilă locală:

"; echo createWidget ()." am creat deja.
"; echo createWidget ()." am creat deja.>
"; ?>

Dar, deoarece variabila $ numWidgets este creată de fiecare dată când funcția este apelată, vom obține următorul rezultat:

Creăm câteva widget-uri... 1 pe care le-am creat deja. 1 pe care l-am creat deja. 1 pe care l-am creat deja.

Dar folosind o variabilă statică, putem stoca valoarea de la un apel de funcție la altul:

"; echo createWidget ()." am creat deja.
"; echo createWidget ()." am creat deja.
"; echo createWidget ()."> am creat deja.
"; ?>

Acum scriptul va produce rezultatul așteptat:

Creăm câteva widget-uri... 1 pe care le-am creat deja. 2 am creat deja. 3 am creat deja.

Deși o variabilă statică își păstrează valoarea între apelurile de funcție, ea este valabilă numai în momentul în care scriptul este executat. De îndată ce scriptul își termină execuția, toate variabilele statice sunt distruse, precum și variabilele locale și globale.

Asta e tot! Verificați frecvent documentația PHP.

Variabilele de mediu (mediu) în Windows conțin diverse informații despre setările sistemului și mediul utilizatorului. Distingeți între variabilele de mediu utilizator, sistem și proces.

Cel mai simplu mod de a vizualiza conținutul variabilelor de mediu pe Windows este să deschideți proprietățile sistemului ( sysdm.cpl) -> Avansat -> Variabile de mediu. După cum puteți vedea, în secțiunea deschisă există două secțiuni: cea de sus conține variabilele de mediu ale utilizatorului, cea de jos le conține pe cele de sistem.

În plus, variabilele de mediu sunt stocate în registrul de sistem. Variabilele personalizate sunt stocate în secțiune. Sistem - în HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

Puteți afișa valorile tuturor variabilelor de mediu în linia de comandă Windows. Comanda este simpla:

Comanda va lista variabilele de mediu și valorile acestora.

În PowerShell, puteți utiliza comanda pentru a afișa toate variabilele de mediu:

Dacă doriți să afișați valoarea unei singure variabile, trebuie să utilizați comanda echo, iar numele variabilei trebuie inclus în semne procentuale. De exemplu,

Echo% systemroot%

set> c: \ tmp \ env_var.txt

Variabilele de mediu ale unui anumit proces pot fi obținute folosind un program gratuit Utilitare Process Explorer(de la Sysinternals). Este suficient să deschideți proprietățile procesului și să accesați fila Mediu inconjurator.

acum 13 ani

Un pic la care trebuie să fii atent:

Dacă dezactivați RegisterGlobals și înrudite, apoi utilizați get_defined_vars (), este posibil să vedeți ceva de genul următor:

Matrice
[GLOBALS] => Matrice
[GLOBALS] => Matrice
*RECURSIUNE*
[_POST] => Matrice ()
[_GET] => Matrice ()
[_COOKIE] => Matrice ()
[_FILES] => Matrice ()
)

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

)
?>

Observați că $ _SERVER nu este acolo. Se pare că php încarcă superglobal $ _SERVER numai dacă este folosit undeva. Puteți face acest lucru:

imprimare "

„. htmlspecialchars (print_r (get_defined_vars (), true)).”

" ;
imprimare "

„. htmlspecialchars (print_r ($ _SERVER, adevărat)).”

" ;
?>

Și apoi $ _SERVER va apărea în ambele liste. Bănuiesc că „nu este chiar o problemă, pentru că nimic rău nu se va întâmpla în orice caz, dar” este o curiozitate interesantă totuși.

acum 6 ani

Deoarece get_defined_vars () primește variabilele doar în punctul în care apelați funcția, există o modalitate simplă de a obține variabilele definite în domeniul curent.

// În partea de sus a scriptului dvs. php
$ vars = get_defined_vars ();

// Acum fă-ți treaba
$ foo = „foo”;
$ bar = "bar";

// Obține toate variabilele definite în domeniul curent
$ vars = array_diff (get_defined_vars (), $ vars);

ecou"

"
;
print_r ($ vars); 
ecou"

" ;
?>

acum 15 ani

Iată o funcție care generează un raport de depanare pentru afișare sau e-mail
folosind get_defined_vars. Excelent pentru a obține un instantaneu detaliat fără
bazându-se pe intrarea utilizatorului.

funcția generateDebugReport ($ metoda, $ defined_vars, $ email = "undefined") (
// Funcție pentru a crea un raport de depanare pentru afișare sau e-mail.
// Utilizare: generateDebugReport (metoda, get_defined_vars (), email);
// Unde metoda este „browser” sau „e-mail”.

// Creați o listă de ignorare pentru cheile returnate de „get_defined_vars”.
// De exemplu, HTTP_POST_VARS, HTTP_GET_VARS și altele sunt
// redundant (la fel ca _POST, _GET)
// Includeți și variantele pe care doriți să le ignorați din motive de securitate - de ex. PHPSESSID.
$ ignorelist = matrice ("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 = data ("m / d / y h: m: s");
$ message = "Raport de depanare creat $ timestamp \ n";

// Obține ultima eroare SQL pentru o măsură bună, unde $ link este identificatorul resursei
// pentru mysql_connect. Comentați sau modificați pentru baza de date sau configurarea abstracției.
link global $;
$ sql_error = mysql_error ($ link);
dacă ($ sql_error) (
mesaj $. = „\ nMesaje Mysql: \ n”. mysql_error ($ link);
}
// Încheiați MySQL

// Ar putea folosi o funcție recursivă aici. Ai inteles ideea ;-)
foreach ($ defined_vars ca $ cheie => $ val) (
if (este_array ($ val) &&! în_array ($ cheie, $ ignorelist) && număr ($ val)> 0) (
mesaj $. = „\ n $ matrice de chei (cheie = valoare): \ n”;
foreach ($ val ca $ subcheie => $ subval) (
if (! in_array ($ subcheie, $ ignorelist) &&! is_array ($ subval)) (
mesaj $. = subcheie $. „=". $ subval. „\ n”;
}
elseif (! in_array ($ subcheie, $ ignorelist) && is_array ($ subval)) (
foreach ($ subval ca $ subsubcheie => $ subsubval) (
if (! in_array ($ subsubcheie, $ ignorelist)) (
mesaj $. = subsubcheie $. „=". $ subsubval. „\ n” ;
}
}
}
}
}
elseif (! is_array ($ val) &&! in_array ($ cheie, $ ignorelist) && $ val) (
mesaj $. = „\ nVariabilă”. tasta $. „=". $ val. „\ n”;
}
}

Dacă (metoda $ == „browser”) (
echo nl2br ($ mesaj);
}
elseif (metoda $ == „e-mail”) (
dacă ($ email == „nedefinit”) (
$ email = $ _SERVER ["SERVER_ADMIN"];
}

$ mresult = mail ($ e-mail, "Raport de depanare pentru". $ _ENV ["HOSTNAME"]. "", $ mesaj);
dacă ($ mresult == 1) (
ecou „Raportul de depanare a fost trimis cu succes. \ N”;
}
altfel (
ecou „Trimiterea raportului de depanare a eșuat. \ N”;
}
}
}
?>

acum 17 ani

Rutină simplă pentru a converti un obiect get_defined_vars în XML.

funcția obj2xml ($ v, $ indent = "") (
while (lista ($ cheie, $ val) = fiecare ($ v)) (
dacă (cheia $ == "__attr") continuă;
// Verificați __attr
if (este_obiect ($ val -> __attr)) (
while (lista ($ key2, $ val2) = fiecare ($ val -> __attr)) (
$ attr. = "$ cheie2 = \" $ val2 \ "";
}
}
else $ attr = "";
dacă (este_matrice ($ val) || este_obiect ($ val)) (
tipărire ("$ indent< $key$attr >\ n ");
obj2xml ($ val, $ indent. "");
tipărire ("$ indent\ n ");
}
else print ("$ indent< $key$attr >$ val\ n ");
}
}

// Exemplu de obiect
$ x -> nume -> primul = "Ioan";
$ x -> nume -> ultimul = "Smith";
$ x -> arr ["Fruit"] = "Bannana";
$ x -> arr ["Veg"] = "Morcov";
$ y -> client = $ x;
$ y -> client -> __attr -> id = "176C4";

$ z = get_defined_vars ();
obj2xml ($ z ["y"]);
?>
va scoate:


Ioan
Smith


Banana
Morcov

acum 11 ani

Ca o notă, get_defined_vars () nu returnează un set de referințe variabile (cum am sperat). De exemplu:

// definește o variabilă
$ my_var = "foo";

// obținem lista noastră de variabile definite
$ defined_vars = get_defined_vars ();

// acum încearcă să schimbi valoarea prin tabloul returnat
$ defined_vars ["my_var"] = "bar";

echo $ my_var, "\ n";

?>

va scoate „foo” (valoarea originală). Ar fi bine dacă get_defined_vars () ar avea un argument opțional pentru a le face referințe, dar îmi imaginez că este o solicitare destul de specializată. O puteți face singur (mai puțin convenabil) cu ceva de genul:

$ defined_vars = matrice ();
$ var_names = array_keys (get_defined_vars ());

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

?>

1 an in urma

Am mai postat aici despre „acest lucru” în get_defined_vars.

Se pare că „nu este întotdeauna acolo, dar în anumite cazuri va apărea în mod inexplicabil.

PHP -r "
test de clasa (
funcția publică a () (var_dump (array_keys (get_defined_vars ())); $ a = 123;)
funcția publică b () (var_dump (array_keys (get_defined_vars ())); $ this;)
}
$ t = test nou ();
$ t-> a ();
$ t-> b ();
"

Matrice ()
matrice („aceasta”)

Acest lucru nu se întâmplă în PHP 7.2, dar se va întâmpla în PHP 5.6.

1 an in urma

Unele comentarii de aici subliniază că această funcție nu va returna referințe. Totuși, returnează nume și numele sunt „referințe”.

Nu aș recomanda sugestiile de aici care îl convertesc în referințe.

Funcția publică x ($ a, $ b, $ c) (
foreach (array_keys (get_defined_vars ()) ca cheie $)
dacă (cheia $! == „aceasta”)
$ asta-> y ($ (tasta $));
}

Funcția publică y (& $ intrare) (
$ intrare ++;
}

În loc de $ () puteți folosi și $$.

Am făcut niște lucruri neplăcute în timpul meu pentru a crea un cod extrem de generic, dar „nu am fost niciodată nevoit să fac ceva ca cel de mai sus. S-ar putea să nu funcționeze (dar ar trebui, deoarece” nu este diferit de $ a [$ cheie]).

Ați putea, de asemenea, să faceți $$ cheia ++, dar „nu am văzut niciodată un cod ca acela care să nu fie” îngrozitor de rău (folosind dinamica unde dinamica „nu este benefică).

Dacă „faceți așa ceva, atunci acordați-i un control suplimentar.