Constante globale PHP. Constante în PHP.

(PHP 5\u003e \u003d 5.3.0, PHP 7)

Această listă de întrebări este împărțită în două părți: întrebări generale și unele caracteristici ale implementării care sunt utile pentru o înțelegere mai completă.

În primul rând, întrebările generale.

1. Dacă nu folosesc spații de nume, ar trebui să fie considerată importantă?
2. Cum pot folosi clasele interne sau globale în spațiul de nume?
3. Cum pot folosi clase în spațiile de nume sau constantele în spațiul lor de nume?
4. Ca. \\ Numele meu sau \\ Nume. transformat?
5. Ca un nume ca numele meu. transformat?
6. Cum este numele incomplet al clasei nume. transformat?
7. Ca un nume incomplet al unei funcții sau un nume incomplet al constantei, cum ar fi nume. transformat?

Unele detalii despre implementarea spațiilor de nume care sunt utile pentru a înțelege.

1. Numele importate nu pot intra în conflict cu clasele definite în același fișier.
2. Nici funcțiile, nici constante nu pot fi deportate folosind operatorul utilizare.
3. Numele de spațiu de nume de nume dinamice (identificatori luați în citate) trebuie să protejeze simbolul conferinței.
4. Consultați Constante nedefinite folosind slash-ul invers, este imposibil. Eroare fatală este afișată
5. Imposibil de înlocuit constante speciale, cum ar fi nul, adevărat, fals, zend_thread_safe sau zend_debug_build

Dacă nu folosesc spații de nume, ar trebui să fie considerată importantă?

Nu. Spațiile de nume nu au nicio influență asupra niciunui cod existent în nici un formular sau niciun cod scris care nu conține spații de nume. Puteți scrie un astfel de cod dacă doriți:

Exemplu # 1 Accesul la clasele globale din afara spațiului de nume

$ a \u003d New \\ stdclass;
?>

Acest lucru este echivalent funcțional cu următoarele:

Exemplul # 2 Accesul la clasele globale din afara spațiului de nume

$ a \u003d noua stdclass;
?>

Cum pot folosi clasele interne sau globale în spațiul de nume?

Exemplul # 3 Accesul la clasele interne în spațiul de nume

spația de nume foo;
$ a \u003d New \\ stdclass;

testul funcției (\\ arrayobject $ TypeHintexample \u003d Null) ()

$ a \u003d \\ directoryitar :: actual_as_fileinfo;

// Extinderea clasei interne sau globale
clasa MyException extinde \\ Excepție ()
?>

Cum pot folosi funcțiile clase în spațiile de nume sau constantele în spațiul lor de nume?

Exemplul # 4 Accesul la clasele interne, caracteristicile sau constantele în spațiul de nume

spația de nume foo;

clasa Myclass ()

// Folosind o clasă din spațiul de nume curent
test de funcții (Myclass $ TypeHintexample \u003d Null) ()
// O altă modalitate de a utiliza o clasă din spațiul de nume curent
test de funcții (\\ foo \\ myclass $ TypeHintexample \u003d Null) ()

// Extinderea clasei din spațiul de nume curent
clasa extinsă extinde Myclass ()

// Accesul la funcția globală
$ a \u003d \\ GlobalFunc ();

// Accesul la constanta globala
$ b \u003d \\ ini_all;
?>

Ca. \\ Numele meu sau \\ Nume. transformat?

Nume care încep cu \ Convertiți întotdeauna la modul în care arată, adică. \\ Numele meu - Într-adevăr numele meu., I. \\ Excepție - aceasta este Excepție.

Exemplu # 5 nume absolute

spația de nume foo;
$ a \u003d New \\ meu \\ nume (); // creează o instanță a clasei "numele meu"
echo \\ strlen ("hi"); // determină funcția "strlen"
$ a \u003d \\ ini_all; // variabila $ A este atribuită valoarea constantă "ini_all"
?>

Ca un nume ca numele meu. transformat?

Numele care conțin slash opus, dar nu încep cu el, cum ar fi numele meu.

aLE MELE. Un alt nume, atunci acest sinonim este aplicat aLE MELE. în numele meu..

numele meu..

Exemplu # 6 Numele complete

spația de nume foo;
utilizați blah \\ blah ca foo;

$ a \u003d nou \\ nume (); // creează o instanță a clasei "foo \\ meu \\ nume"
foo \\ bar :: nume (); // Cauze metoda statica "Nume" in clasa "Blah \\ Blah \\ Bar"
meu \\ bar (); // provoacă funcția "foo \\ meu \\ bar"
$ a \u003d barul meu; // atribuie o variabilă $ o înțeles constantă "foo \\ meu \\ bar"
?>

Cum este numele incomplet al clasei nume. transformat?

Nume de clasă care nu conțin o slash inversă, cum ar fi nume. Pot fi convertite două moduri diferite.

Dacă este prezent o expresie de import, ceea ce creează sinonim nume. Un alt nume, atunci se folosește acest sinonim.

În caz contrar, numele curent al spațiului de nume devine prefixul la numele meu..

Exemplu # 7 Numele clasa incompletă

spația de nume foo;
utilizați blah \\ blah ca foo;

$ a \u003d Nume nou (); // creează o instanță a clasei "foo \\ nume"
foo :: nume (); // Cauze metoda statica "Nume" in clasa "Blah \\ Blah"
?>

Ca un nume incomplet al unei funcții sau un nume incomplet al constantei, cum ar fi nume. transformat?

Caracteristicile sau constantele care nu conțin un stupid invers, cum ar fi nume. Pot fi convertite două moduri diferite.

În primul rând, numele curent al spațiului de nume devine un prefix la nume..

Apoi, dacă o constantă sau o funcție nume. Nu există în spațiul de nume curent, este utilizată o constantă globală sau o funcție nume.dacă există.

Exemplu # 8 Numele incomplete de funcții sau constante

spația de nume foo;
utilizați blah \\ blah ca foo;

const foo \u003d 1;

funcția mea () ()
funcție foo () ()
funcție Sortare (& $ a)
{
\\ Sort ($ a); // Cauzează funcția globală "Sortare"
$ a \u003d array_flip ($ a);
Returnați $ a;
}

Ale mele (); // cauzează "foo \\ meu"
$ a \u003d strlen ("hi"); // determină funcția globală "strlen", deoarece "foo \\ strlen" nu există
$ arr \u003d matrice (1, 3, 2);
$ b \u003d sortare ($ arr); // sună funcția "foo \\ sortare"
$ C \u003d foo (); // Cauzează funcția "Foo \\ foo" - importurile nu se aplică

$ a \u003d foo; // atribuie o variabilă $ o înțeles constantă "foo \\ foo" - import nu se aplică
$ b \u003d ini_all; // atribuie o valoare variabilă de $ B a constantei globale "ini_all"
?>

Numele importate nu pot intra în conflict cu clasele definite în același fișier.

Următoarele combinații de scripturi sunt permise:

nameSpace My \\
clasa Myclass ()
?>

spațiul de nume;
class ()
?>

nameSpace My \\
includ "File1.php";
includ "animotot.php";

$ a \u003d Myclass nou; // creează o instanță a clasei "lucru" din spațiul de nume "altul"
?>

Numele conflictului nu este nici măcar în ciuda faptului că clasa Clasa mea. există în interiorul spațiului de nume lucrurile meleDeoarece definiția Myclass se află într-un fișier separat. Cu toate acestea, următorul exemplu duce la o eroare fatală cu un conflict de nume, deoarece clasa MyClass este definită în același fișier în care este declarația de utilizare.

nameSpace My \\
utilizați un alt lucru ca myclass;
clasa Myclass () // eroare fatală: conflictul myclass cu expresia de import
$ a \u003d Myclass nou;
?>

Spațiile de nume neimplicate sunt inacceptabile.

PHP nu permite atașarea spațiilor de nume una la alta

nameSpace My \\
Namespace imbricate (
Clasa foo ()
}
}
?>

Cu toate acestea, pentru a simula spații de nume nespensate astfel:

spațiul de nume \\ chestii \\ qusted (
Clasa foo ()
}
?>

La PHP 5.6 nici funcțiile, nici constantele nu ar putea fi importate utilizând operatorul utilizare.

La PHP 5.6 elemente unice care fac obiectul acțiunii operatorului utilizare - Acestea sunt spațiile de nume ale numelor și numele clasei. Pentru a reduce numele lungi ale constantelor sau funcțiilor, inhibă conținutul lor în spațiul de nume.

mina spațiului de nume;
utilizați numele Ultra \\ Long \\ ns \\

$ A \u003d nume \\ constant;
name \\ func ();
?>

Începând cu PHP 5.6 a devenit posibilă importul și crearea Psedonyms pentru funcțiile și numele constantelor.

Numele de spațiu de nume de nume dinamice (identificatori luați în citate) trebuie să protejeze simbolul conferinței.

Este foarte important să reprezentăm acest lucru, deoarece stratul invers este folosit ca un caracter de protecție în interiorul rândurilor. Acesta ar trebui să fie întotdeauna duplicat atunci când este utilizat în interiorul șirului, altfel apare riscul de consecințe neintenționate:

Exemplu # 9 capcane atunci când se utilizează numele spațiului de nume în interiorul unui dublu citate

$ a \u003d "nume periculos"; // \\ n este o tranziție la o nouă linie din interiorul unui rând cu citate duble!
$ Obj \u003d nou $ a;

$ a \u003d "nu \\ la \\ toate \\ periculos"; // Și aici nu există probleme.
$ Obj \u003d nou $ a;
?>

În interiorul liniilor închise în citate unice, reacția ca un separator este mai sigură, dar a recomandat încă o practică de screening de duș inversă în toate rândurile este cea mai bună opțiune.

Consultați Constante nedefinite folosind slash-ul invers, este imposibil. Eroare fatală este afișată

Orice constantă nedefinită, care este un nume incomplet ca Foo.va duce la concluzia că PHP a sugerat acest lucru Foo. A existat o valoare a constantei. Orice constantă, cu un nume complet sau absolut, care conține simbolul stratului invers va duce la o eroare fatală dacă nu este găsită.

Exemplu # 10 Constantele incerte

barul spațiului de nume;
$ a \u003d foo; // afișează un avertisment: constante nedefinite "foo" asumate "foo";
$ a \u003d \\ foo; // eroare fatală: spațiul de nume nedefinit Foo
$ a \u003d bar \\ foo; // eroare fatală: spațiu de nume nedefinit Bar \\ bar \\ foo
$ a \u003d \\ bar \\ foo; // eroare fatală: spațiu nedefinit spațiu constant \\ foo
?>

Imposibil de înlocuit constante speciale, cum ar fi nul, adevărat, fals, zend_thread_safe sau zend_debug_build

Orice încercare de a determina constanta spațiului de nume, care coincide cu numele constantelor speciale încorporate, va duce la o eroare fatală.

Exemplu # 11 Constante incerte

barul spațiului de nume;
const null \u003d 0; // Eroare fatala;
const adevărat \u003d "stupid"; // și eroare fatală;
// etc.
?>

cu 7 ani în urmă.

Există o modalitate de a defini o constantă de nume de nume care este o constantă specială, încorporată, folosind definirea funcției și setarea celui de-al treilea parametru Case_inSensitiv la False:

spația de nume foo;
definiți (__namespace__. "\\ Null", 10); // definește constanta null în spațiul de nume curent


?>

Nu este nevoie să specificați spațiul de nume în apelul dvs. pentru a defini (), cum se întâmplă de obicei
spația de nume foo;
definiți (INI_ALL, "BAR"); // produce notificare - constant INI_ALL deja definit. Dar:

Definiți (__namespace__. "\\ Ini_all", "bar"); // definește constanta ini_all în spațiul de nume curent
var_dump (ini_all); // va afișa șir (3) "bar". Nimic neașteptat până acum. Dar:

Definiți ("null", 10); // definește constanta null în spațiul de nume curent ...
var_dump (null); // va arăta 10
var_dump (null); // va arăta nul
?>

Dacă parametrul case_inSensitiv este setat la adevărat
spația de nume foo;
defini (__namespace__. "\\ Null", 10, adevărat); // produce notificare - constant null deja definit
?>

Acum 3 ani.

La crearea unor clase sau apelarea metodelor statice din interiorul spațiilor de nume folosind variabile, aveți nevoie de spațiul de nume complet pentru ca clasa corespunzătoare să fie utilizată; Nu puteți utiliza un alias sau un nume scurt, chiar dacă se numește în același spațiu de nume. Neglijarea de a lua acest lucru poate face ca codul dvs. să utilizeze clasa greșită, aruncați o excepție de clasă lipsă fatală sau aruncați erori sau avertismente.

În aceste cazuri, puteți utiliza constanta magică __nameSpace__, opecifici direct spațiul de nume complet și numele clasei. Funcția de clasă_exists necesită, de asemenea, spațiul de nume complet și numele clasei și pot fi folosite pentru a se asigura că o eroare fatală nu va fi aruncată din cauza unor clase lipsă.

Spația de nume foo;
bar de clasă (
Test de funcții publice statice () ()
Retur get_called_class ();
}
}

namespace foo \\ foo;
barul de clasă se extinde \\ foo \\ bar (
}

Var_dump (bar :: test ()); // șir (11) "foo \\ foo \\ bar"

$ Bar \u003d "foo \\ bar";
var_dump ($ bar :: test ()); // șir (7) "foo \\ bar"

$ Bar \u003d __namespace____. "\\ Bar";
var_dump ($ bar :: test ()); // șir (11) "foo \\ foo \\ bar"

$ Bar \u003d "bar";
var_dump ($ bar :: test ()); // eroare fatală: clasa "bar" nu a fost găsită sau incorectă clasa utilizată

Pentru fiecare script executabil. Multe dintre aceste constante sunt determinate de diferite module și vor fi prezente numai dacă aceste module sunt disponibile ca urmare a unei sarcini dinamice sau ca rezultat al ansamblului static.

Există nouă constante magice care își schimbă valoarea în funcție de contextul în care sunt utilizate. De exemplu, valoare __Linia__ Depinde de rândul din scriptul pe care este indicat această constatare. Toate constantele magice sunt permise în timpul compilării, spre deosebire de constantele convenționale care sunt permise în timpul executării. Constantele speciale sunt insensibile la registru, iar lista lor este prezentată mai jos:

Unele constante magice PHP

Nume	Descriere
__Linia__	Numărul de linie curent în fișier.
__Fişier__	Calea completă și numele fișierului curent cu SIMINKS implementate. Dacă este utilizat în interiorul fișierului plug-in, atunci numele acestui fișier este returnat.
__Dir__	Director de fișiere. Dacă este utilizat în interiorul fișierului plug-in, directorul acestui fișier este returnat. Acest lucru este echivalent cu apelarea dIRNAME (__ File__). Numele de returnare al directorului nu se termină pe Lay, cu excepția directorului rădăcină.
__Funcţie__	Numele funcției Or. (Închidere) În cazul în care o funcție anonimă.
__Clasă__	Numele clasei. Acest nume conține numele spațiului de nume, în care a fost anunțată clasa (de exemplu, Foo \\ bar.). Vă rugăm să rețineți că începând cu PHP 5.4 __class__ funcționează, de asemenea, în trăsături. Când este utilizat în metodele de trăsături __class__ este numele clasei în care sunt utilizate aceste metode.
__Trăsătură__	Numele trăsăturii. Acest nume conține numele spațiului de nume, în care a fost declarată trăsătura (de exemplu, Foo \\ bar.).
__Metodă__	Numele metodei de clasă.
__Namespace__	Numele spațiului de nume curent.
ClasaName :: Clasa	Nume de clasă completă (indicând spațiul de nume). Vezi si :: Clasa.

Vezi si get_class () , get_object_vars () , fisierul exista () și funcții_exists () .

Lista modificărilor

Acum 14 ani.

Diferența dintre.
__Function__ și __method__ ca în PHP 5.0.4 este asta

Funcția__ returnează numai numele funcției

În timp ce __method__ returnează numele clasei de-a lungul numelui funcției

clasa trick.
{
Funcția Doit ()
{
ECHO __function__;
}
Funcția Doitagain ()
{
Echo __method__;
}
}
$ Obj \u003d truc nou ();
$ Obj-\u003e doit ();
ieșirea va fi ----
$ Obj-\u003e DOITAGAIN ();
ieșire va fi ----- trick :: DoitaGain

Acum 13 ani.

__Class__ Magic constantă frumos completează funcția get_class ().

Uneori trebuie să știți atât:
- Numele clasei moștenite
- numele clasei executate efectiv

Iată un exemplu care arată soluția posibilă:

Clasa base_class.
{
Funcția Say_a ()
{

" ;
}

Funcția Say_B ()
{

" ;
}

clasa derivate_class extinde base_class
{
Funcția Say_a ()
{
părinte :: Say_a ();
Echo "" A "- a spus". __Clasă__. "
" ;
}

Funcția Say_B ()
{
părinte :: Say_B ();
Echo "" B "- a spus". get_class ($ acest). "
" ;
}
}

$ Obj_b \u003d nou derivate_class ();

$ Obj_b -\u003e Say_a ();
echo "
" ;
$ Obj_b -\u003e Say_b ();

?>

Shld-ul de ieșire arată aproximativ așa:

"A" - a spus base_class
"A" - a spus derivate_class

"B" - a spus derivate_class
"B" - a spus derivate_class

Acum 3 ani.

Observați o mică inconsecvență atunci când utilizați __class__ și __method__ în trăsături (stand PHP 7.0.4): În timp ce __class__ lucrează așa cum este anunțat și returnează dinamic numele clasei este utilizată în, __method__ va preface efectiv numele trăsăturii în loc de Numele clasei!

acum 8 ani.

Nu există nici o modalitate de a implementa un __dir__ compatibil înapoi în versiuni înainte de 5.3.0.

Singurul lucru pe care îl puteți face este să efectuați o căutare recursivă și să înlocuiți la DIRNAME (__ File__):
găsi. -Type F -print0 | Xargs -0 sed -i "s / __ dir __ / dirname (__ fișier __) /"

acum 5 ani.

O mulțime de note aici se referă la definirea constantă a magicului __dir__ pentru versiunile PHP care nu susțin caracteristica. Bineînțeles că puteți defini această constantă magică pentru versiunile PHP care nu au încă această constantă, dar va învinge scopul de îndată ce sunteți o utilizare constantă într-un fișier inclus, care poate fi într-un director diferit, apoi fișierul care definește __dir__ Constant. Ca atare, constanta și-a pierdut * Magic * și ar fi destul de inutil decât dacă vă asigurați că aveți toate acestea în același director.

În concluzie: Ochelarch Catchup la gmail dot com's Notă privind dacă nu puteți defini constantele magice este valabil, dar afirmând că definirea __dir__ nu este inutilă, nu este!

cu 7 ani în urmă.

Nu puteți verifica dacă este definită o constantă magică. Aceasta înseamnă că nu există niciun punct de a verifica dacă __dir__ este definit apoi, definirea acestuia. "Definit (" __ dir __ ")` întotdeauna returnează fals. Definirea __dir__ va eșua în tăcere în php 5.3+. Acest lucru ar putea provoca probleme de compatibilitate dacă scriptul dvs. include alte scripturi.

echo (definit ("__dir__")? "__Dir__ este definit": "__dir__ nu este definit." PHP_EOL);
echo (definit ("__file__")? "__File__ este definit": "__file__ nu este definit." PHP_EOL);
eCHO (definit ("PHP_VERSION")? "PHP_VERSION este definit": "PHP_VERSION nu este definit"). Php_eol;
eCHO "Versiune PHP:". Php_version. Php_eol;
?>
Ieșire:
__Dir__ nu este definit
__File__ nu este definită
PHP_VERSION este definit.
Versiune PHP: 5.3.6

Există cazuri în care variabilele sunt destul de incomode pentru a utiliza orice valori specifice pentru stocarea constantă care nu se schimbă în timpul programului. Aceste valori pot fi constante matematice, căi către fișiere, o varietate de parole etc. Doar în aceste scopuri în PHP există un astfel de design ca.

numit o valoare numită care nu se schimbă în timpul executării programului (script).

În constantele RNR sunt determinate de funcția defini () . Această caracteristică are următorul format:

defini ($ Nume., $ valoare, $ Caz_sen.), Unde:

$ Nume. - numele constantei;
$ valoare - constantă de valoare;
$ Caz_sen. - parametrul opțional al tipului logic,
Indicând dacă ar trebui luată în considerare cazul literelor (adevărat) sau nu (fals).

Un exemplu de determinare și utilizare a constantelor PHP:

echo pi;
// Afișează 3.14.
?>

Dacă parametrul $ Caz_sen. Corb adevărat.Interpretul va lua în considerare registrul de simbol atunci când lucrați cu constanta. Vă rugăm să rețineți că constante sunt utilizate fără un semn precedent. $ .

Diferențele dintre constante și variabile:

Constant nici o consolă sub forma unui semn de dolar ( $ );

Constantele pot fi definite doar folosind funcția defini () și nu alocarea valorii;

Constantele pot fi definite și disponibile oriunde fără a lua în considerare domeniul de aplicare;

Constantele nu pot fi determinate sau anulate după anunțul inițial;

Constantele pot avea decât valori scalare.

Verificarea existenței constantelor

Pentru a verifica existența constantă, puteți utiliza funcția definit () . Această caracteristică se întoarce adevărat.dacă este declarată constanta. Să dăm un exemplu:

// declară o constantă
defini ("pi", 3.14, adevărat);
dacă (definit ("pi") \u003d\u003d adevărat) ecou "Constant este anunțat!";
// Scriptul va afișa "PI Constant este anunțat!"
?>

Constantele PHP predefinite

Există următoarele constante predefinite în PHP:

PHP oferă o listă mare de constante predefinite pentru fiecare script executabil. Multe dintre aceste constante sunt determinate de diferite module și vor fi prezente numai dacă aceste module sunt disponibile ca urmare a unei sarcini dinamice sau ca rezultat al ansamblului static.

Există cinci constante predefinite care își schimbă valoarea în funcție de contextul în care sunt utilizate. De exemplu, Constanța __Linia__ Depinde de rândul din scriptul pe care este indicat această constatare. Constantele speciale sunt insensibile la registru, iar lista lor este prezentată mai jos:

Nume	Descriere
__Linia__	Linia curentă în fișier.
__Fişier__	Calea completă și numele fișierului curent.
__Dir__	Directorul fișierului. Dacă este utilizat în interiorul unei includeri, directorul fișierului inclus este returnat. Acest lucru este echivalent cu DIRNAME (__ File__). Numele acestui director nu are o tradiție slash decât dacă este directorul rădăcină.
__Funcţie__	Numele funcției. (Adăugat la PHP 4.3.0.)
__Clasă__	Numele clasei. (Adăugat la PHP 4.3.0.)
__Trăsătură__	Numele trăsăturii. Numele TAIT include spațiul de nume A fost declarat în (de exemplu, foo \\ bar).
__Metodă__	Numele metodei de clasă. (Adăugat la PHP 5.0.0)
__Namespace__	Numele spațiului de nume curent.

În plus

Ultima actualizare: 1.11.2015

Constante, precum și variabilele stochează o valoare specifică, numai în contrast cu variabilele, valoarea constantei poate fi instalată numai o singură dată și apoi nu mai putem schimba. De exemplu, definim o constantă numerică:

Pentru a determina constanta, se utilizează operatorul de definire, care are formularul de mai jos: Definiți (String $ Nume, string $ valoare, bool $ cazs_sen \u003d false). Parametrul Nume transmite numele constanta, iar parametrul de valoare $ este valoarea sa. Al treilea parametru opțional primește valoarea logică adevărată sau falsă. Dacă valoarea este falsă, atunci când utilizați constanta va fi luată în considerare registrul său, dacă este adevărat - registrul nu este luat în considerare. În cazul nostru, al treilea parametru nu este utilizat, deci este egal cu falsul în mod implicit.

După determinarea constantă, îl putem folosi, precum și variabila obișnuită. Singura excepție - nu vom putea să-i schimbăm sensul. O altă diferență față de variabilă nu este de a folosi semnul $. Adică numărul de expresie este numărul \u003d 33; Nu va merge.

Constantari predefinite

În plus față de programatorul creat de programator, există mai multe constante mai încorporate în PHP:

File__: stochează calea și numele complet al fișierului curent

LINE__: stochează numărul de linie curent la procesele de interpretare

Dir__: stochează directorul de fișiere curent

Funcție__: Numele funcției prelucrate

CLASS__: Numele clasei curente

Metoda: Numele metodei procesate

NameSpace__: Numele spațiului de nume curent

De exemplu, retrageți șirul executiv curent și numele fișierului:

Verificarea existenței Constanța

Pentru a verifica dacă constante sunt definite, putem folosi funcția BOOL definită (String $ Name). Dacă este definită o constantă de nume, funcția se va întoarce la TRUE