Konstantes- tās ir vērtības, kas laika gaitā nemainās. Pat no skolas laikiem jūs droši vien zināt daudzas konstantes, piemēram, skaitli P, numurs e, paātrinājums Brīvais kritiens un citi. Un, protams, programmējot arī ļoti bieži ir jāievada konstantes. Un par to, kā izveidot un izmantot konstantes PHP, mēs par to runāsim šajā rakstā.

Iesim tev līdzi izveidosim konstanti cipariem P:

definēt(PI, 3,1415926);
atbalss PI;
?>

Operators definēt rada nemainīgs P.I. un piešķir tai vērtību 3.1415926 . Tālāk mēs izvadām šo konstanti caur operatoru atbalss. Viss ir ļoti vienkārši, tomēr ir viens ieteikums, kuru iesaku vienmēr ievērot. Noteikti rakstiet konstantes ar lielajiem burtiem. Tas nav nepieciešams, bet ļoti vēlams. Un tas ir ierasts ne tikai PHP, bet arī citās valodās.

Protams, vēlāk maiņas konstante PI netiks atļauts (tāpēc viņa nemainīgs).

Tagad apskatīsim vienu funkciju, kas pārbauda: " Vai dotā konstante ir definēta?". Uzrakstīsim šo skriptu:

if (!defined("PI")) define(PI, 3.1415926);
atbalss PI;
?>

Šeit tiek pārbaudīta konstantes esamība P.I.. Un, ja tā neeksistē (tas ir define() funkcija atgriezās viltus), tad mēs inicializējam šo konstanti. Tad mēs to vienkārši parādām.

Kā redzat, izveidojiet un izmantojiet savu konstantes PHP- tas ir ļoti vienkārši.

Un visbeidzot es gribētu runāt par iebūvētās PHP konstantes. Uzrakstīsim vienkāršu skriptu:

phpinfo ();
?>

Beigās ir sadaļa " PHP mainīgais"Patiesībā tas nav pilnībā konstantes tomēr tie ir konstantes izpildot šo skriptu. Protams, kad tiek izpildīts cits skripts, tiem būs atšķirīgas vērtības (protams, ne visas). Izvedīsim jūs kā pāri konstantes, lai jūs saprastu, kā ar tiem strādāt, jo tie tiek izmantoti neticami bieži:

echo $_SERVER["REMOTE_ADDR"];
atbalss"
";
echo $_SERVER["QUERY_STRING"];
?>

Šajā skriptā mēs izvadām Lietotāja IP adrese, kas palaida skriptu, un nākamajā rindā mēs parādām vaicājuma virkni (piemēram, " index.php?id=7"). Nedaudz raugoties uz priekšu, es saku, ka šeit mēs strādājam ar globālo masīvs $_SERVER. Ar masīviem iepazīsimies vēlāk, bet domāju, ka tie, kas strādājuši ar masīviem citās programmēšanas valodās, sintaksi atpazīs bez problēmām. Kas attiecas uz citiem konstantes, tad darbs ar tiem notiek tāpat.

Katram izpildītajam skriptam. Daudzas no šīm konstantēm definē dažādi moduļi, un tās būs pieejamas tikai tad, ja šie moduļi būs pieejami, izmantojot dinamisku ielādi vai statisku montāžu.

Ir deviņas maģiskās konstantes, kas maina savu nozīmi atkarībā no konteksta, kurā tās tiek izmantotas. Piemēram, vērtība __LINE__ ir atkarīgs no skripta rindas, kurā ir norādīta šī konstante. Visas maģiskās konstantes tiek atrisinātas kompilēšanas laikā, atšķirībā no parastajām konstantēm, kuras tiek atrisinātas izpildes laikā. Īpašās konstantes nav reģistrjutīgas, un tās ir norādītas tālāk:

Dažas burvju PHP konstantes

Vārds	Apraksts
__LINE__	Pašreizējais rindas numurs failā.
__FILE__	Pašreizējā faila pilns ceļš un nosaukums ar izvērstām saitēm. Ja to izmanto iekļautā failā, tiek atgriezts šī faila nosaukums.
__DIR__	Failu direktorijs. Ja tiek izmantots iekļautā failā, tiek atgriezts šī faila direktorijs. Tas ir līdzvērtīgs zvanīšanai dirname (__FILE__). Atgrieztais direktorija nosaukums nebeidzas ar slīpsvītru, izņemot saknes direktoriju.
__FUNCTION__	Funkcijas nosaukums vai (slēgšana) anonīmas funkcijas gadījumā.
__KLASE__	Klases nosaukums. Šis nosaukums satur tās nosaukumvietas nosaukumu, kurā klase tika deklarēta (piemēram, Foo\Bar). Lūdzu, ņemiet vērā, ka kopš PHP 5.4 __CLASS__ darbojas arī pazīmēs. Lietojot pazīmju metodēs, __CLASS__ ir tās klases nosaukums, kurā metodes tiek izmantotas.
__TRAIT__	Iezīmes nosaukums. Šajā nosaukumā ir ietverta nosaukumvieta, kurā tika deklarēta iezīme (piemēram, Foo\Bar).
__METODE__	Klases metodes nosaukums.
__NAMESPACE__	Pašreizējās nosaukumvietas nosaukums.
Klases nosaukums::klase	Pilnais vārds klase (norādot nosaukumvietu). Skatīt arī ::klase.

Skatīt arī get_class(), get_object_vars(), file_exists() Un funkcija_eksist().

Izmaiņu saraksts

pirms 14 gadiem

Atšķirība starp
__FUNCTION__ un __METHOD__ tāpat kā PHP 5.0.4 ir tā

FUNCTION__ atgriež tikai funkcijas nosaukumu

savukārt kā __METHOD__ atgriež klases nosaukumu kopā ar funkcijas nosaukumu

klases triks
{
funkcija doit()
{
atbalss __FUNCTION__;
}
funkcija doitagain()
{
atbalss __METODE__;
}
}
$obj=jauns triks();
$obj->doit();
izvads būs ---- doit
$obj->doitagain();
izvade būs ----- triks::doitagain

pirms 13 gadiem

Burvju konstante __CLASS__ lieliski papildina funkciju get_class().

Dažkārt tev vajag zināt abus:
- mantotās klases nosaukums
- faktiski izpildītās klases nosaukums

Šeit ir piemērs, kas parāda iespējamo risinājumu:

Klase bāzes_klase
{
funkcija say_a()
{

" ;
}

Funkcija say_b()
{

" ;
}

class derived_class paplašina bāzes_klasi
{
funkcija say_a()
{
vecāks::say_a();
atbalss ""a" - teica " . __KLASE__ . "
" ;
}

Funkcija say_b()
{
vecāks::say_b();
atbalss ""b" - teica " . get_class($this) . "
" ;
}
}

$obj_b = jauna atvasināta_klase();

$obj_b -> say_a();
atbalss"
" ;
$obj_b -> say_b();

?>

Izvadei vajadzētu izskatīties aptuveni šādi:

"a" - teica bāzes_klase
"a" - teica atvasinātā_klase

"b" - teica atvasinātā_klase
"b" - teica atvasinātā_klase

pirms 3 gadiem

Ņemiet vērā nelielu neatbilstību, izmantojot īpašībās __CLASS__ un __METHOD__ (standarts php 7.0.4): Kamēr __CLASS__ darbojas kā reklamēts un dinamiski atgriež tās klases nosaukumu, kurā iezīme tiek izmantota, __METHOD__ faktiski pievienos iezīmes nosaukumu, nevis klases nosaukums!

pirms 8 gadiem

Nav iespējams ieviest atpakaļsaderīgu __DIR__ versijās, kas vecākas par 5.3.0.

Vienīgais, ko varat darīt, ir veikt rekursīvu meklēšanu un aizstāt to ar dirname (__FILE__):
atrast. -tipa f -print0 | xargs -0 sed -i "s/__DIR__/dirname(__FILE__)/"

pirms 5 gadiem

Daudzas piezīmes šeit attiecas uz burvju konstantes __DIR__ definēšanu PHP versijām, kas neatbalsta šo līdzekli. Protams, jūs varat definēt šo maģisko konstanti PHP versijām, kurām vēl nav šīs konstantes, taču tā zaudēs savu mērķi, tiklīdz izmantosit konstanti iekļautajā failā, kas var atrasties citā direktorijā nekā failā, kas definē konstanti __DIR__. . Tādējādi konstante ir zaudējusi savu *maģisko spēku* un būtu diezgan bezjēdzīga, ja vien nepārliecināsities, ka visi iekļautie ir vienā direktorijā.

Secinājums: acu uztveršana gmail dot com piezīmē par to, vai varat vai nevar definēt maģiskās konstantes, ir derīga, taču apgalvojums, ka __DIR__ definēšana nav bezjēdzīga, tā nav!

pirms 7 gadiem

Jūs nevarat pārbaudīt, vai ir definēta burvju konstante. Tas nozīmē, ka nav jēgas pārbaudīt, vai __DIR__ ir definēts, pēc tam to definēt. `defined("__DIR__")` vienmēr atgriež false. PHP 5.3+ versijā __DIR__ definēšana klusi neizdosies. Tas var izraisīt saderības problēmas, ja jūsu skriptā ir iekļauti citi skripti.

echo (definēts ("__DIR__" ) ? "__DIR__ ir definēts" : "__DIR__ NAV definēts" . PHP_EOL );
echo (definēts ("__FILE__" ) ? "__FILE__ ir definēts" : "__FILE__ NAV definēts" . PHP_EOL );
echo (definēts ("PHP_VERSION" ) ? "PHP_VERSION ir definēts" : "PHP_VERSION NAV definēts" ) . PHP_EOL ;
echo "PHP versija: " . PHP_VERSION. PHP_EOL ;
?>
Izvade:
__DIR__ NAV definēts
__FILE__ NAV definēts
PHP_VERSION ir definēts
PHP versija: 5.3.6

Pēdējā atjaunināšana: 1.11.2015

Konstantes, tāpat kā mainīgie, saglabā noteiktu vērtību, bet atšķirībā no mainīgajiem, konstantes vērtību var iestatīt tikai vienu reizi, un tad mēs to nevaram mainīt. Piemēram, definēsim skaitlisko konstanti:

Lai definētu konstanti, izmantojiet definēšanas operatoru, kam ir šāda forma: define(string $name, string $value, bool $case_sen=false) . Parametrs $name norāda konstantes nosaukumu, bet parametrs $value norāda tās vērtību. Trešajam izvēles parametram ir Būla vērtība taisnība vai viltus. Ja vērtība ir nepatiesa, tad, izmantojot konstanti, tās reģistrs tiks ņemts vērā, ja patiess, reģistrs netiks ņemts vērā. Mūsu gadījumā trešais parametrs netiek izmantots, tāpēc pēc noklusējuma tas ir nepatiess.

Pēc konstantes definēšanas mēs to varam izmantot tāpat kā parasto mainīgo. Vienīgais izņēmums ir tas, ka mēs nevarēsim mainīt tā vērtību. Vēl viena atšķirība ar mainīgo ir tā, ka jums nav jāizmanto zīme $. Tas ir, izteiksme NUMBER=33; nedarbosies.

Iepriekš noteiktas konstantes

Papildus programmētāja izveidotajām konstantēm, PHP ir vairākas iebūvētas konstantes:

FILE__ : saglabā pilnu pašreizējā faila ceļu un nosaukumu

LINE__ : saglabā pašreizējās rindas numuru, ko tulks apstrādā

DIR__: saglabā pašreizējā faila direktoriju

FUNCTION__: apstrādājamās funkcijas nosaukums

CLASS__: pašreizējās klases nosaukums

METHOD__: apstrādājamās metodes nosaukums

NAMESPACE__ : pašreizējās nosaukumvietas nosaukums

Piemēram, izdrukāsim pašreizējo izpildāmo rindu un faila nosaukumu:

Konstantes esamības pārbaude

Lai pārbaudītu, vai konstante ir definēta, mēs varam izmantot bool definēto (string $name) funkciju. Ja ir definēta konstante $name, funkcija atgriezīs true

Konstante ir vienkāršas vērtības identifikators (nosaukums). Kā norāda nosaukums, to vērtība nevar mainīties skripta izpildes laikā (izņemot maģiskās konstantes, kas patiesībā nav konstantes). Pastāvīgie nosaukumi pēc noklusējuma ir reģistrjutīgi. Pēc vienošanās nemainīgie nosaukumi vienmēr tiek rakstīti ar lielajiem burtiem.

Konstantes nosaukumam ir jāatbilst tiem pašiem nosaukšanas noteikumiem kā citiem nosaukumiem PHP. Derīgs nosaukums sākas ar burtu vai pasvītru, kam seko jebkurš burtu, ciparu un pasvītru skaits. Regulāra izteiksme lai pārbaudītu nemainīgā nosaukuma pareizību, tas izskatās šādi: ^*$

Ir iespējams definēt konstantes, izmantojot funkciju definēt () rezervēti vai pat nederīgi nosaukumi, kuru vērtības var (tikai) iegūt, izmantojot funkciju konstante (). Tomēr tas nav ieteicams.

1. piemērs. Pareizi un nepareizi konstantu nosaukumi

// Pareizi konstantu nosaukumus
definēt ("FOO" , "kaut kas");
define ("FOO2" , "kaut kas cits" );
define ("FOO_BAR" , "kaut kas vairāk" );

// Nepareizi konstantu nosaukumi
definēt ("2FOO" , "kaut kas");

// Šī ir derīga deklarācija, taču labāk to neizmantot:
// PHP kādu dienu var reģistrēt burvju konstanti,
// kas izjauks skriptu
define ("__FOO__" , "kaut kas");

?>

komentēt: Jēdziens "burti" šeit ir rakstzīmes a-z, A-Z un citas rakstzīmes ar ASCII kodiem no 128 līdz 255 (0x80-0xff).

Pirms 2 gadiem

Konstantu veiktspēja. PHP 7.1.10 32 biti (aktīva Opcache, Windows 10 i7–64 biti), taču šķiet, ka tendences ir tādas pašas ar 5.x

izmantojot konstanti, ko deklarē DEFINE("CNS",vērtība): 0.63575601577759s
izmantojot konstanti, ko deklarē const CNS=vērtība: 0.61372208595276s
izmantojot mainīgo, ko deklarē $v=value: 0.51184010505676s

Vidēji DEFINE un CONST lietojums ir aptuveni vienāds ar CONST labāku veiktspēju, nevis DEFINE. Tomēr mainīgā lieluma izmantošana ir par aptuveni 10–50% labāka nekā konstantes izmantošana. Tātad intensīvam uzdevumam konstante nav labākais risinājums.

$p1=mikrolaiks(patiess);
$x=0;
for($i=0;$i<50000000;$i++) {
$x+=CNS;
}
$p2=mikrolaiks(true);

pirms 14 gadiem

Nedefinēta konstante tiek novērtēta kā patiesa, ja to neizmanto pareizi. Sakiet, piemēram, jums bija kaut kas līdzīgs šim:

iestatījumi.php
// Atkļūdošanas režīms
define ("DEBUG" , false );
?>

test.php
include("settings.php" );

ja (ATkļūdošana) (
// atbalso dažus sensitīvus datus.
}
?>

Ja kāda iemesla dēļ settings.php netiek iekļauts un DEBUG konstante nav iestatīta, PHP JOPROJĀM izdrukās sensitīvos datus. Risinājums ir tos novērtēt. Piemēram:

iestatījumi.php
// Atkļūdošanas režīms
definēt ("ATkļūdošana" , 0 );
?>

test.php
include("settings.php" );

if (ATKLĀŠANA == 1 ) (
// atbalso dažus sensitīvus datus.
}
?>

Tagad tas darbojas pareizi.

Šajā rakstā mēs uzzināsim, kāda ir atšķirība PHP reklāma konstantes, izmantojot atslēgvārdu const un funkciju define().

PHP konstantes ir “konstantes”, kuru vērtības tiek norādītas tikai vienu reizi, un pēc tam tās nevar mainīt. Ja mēģināsit mainīt vērtību, tā nemainīsies un parādīsies PHP piezīme: “Konstante jau definēta”:

Define("FOO", "val"); define("FOO", "val2"); // Piezīme: Pastāvīga jau definēta echo FOO; //> val

PHP ir divi veidi, kā deklarēt konstantes:

// 1 define("NAME", "VALUE"); // 2 const NOSAUKUMS = "VALUE";

Katrai metodei ir savas īpatnības, lai tās saprastu, apskatīsim visu soli pa solim, kā un kas mainījās ar katru PHP versiju.

Kā izveidot konstantes

PHP ir mazāks par 5.3

Pirms 5.3 PHP konstantes varēja definēt, tikai izmantojot define() . Atslēgvārds const parādījās versijā 5.3.

Konstantes var saglabāt tikai skalāri. Skalārie mainīgie ir mainīgie, kuru tipi ir integer, float, string un Boolean. Masīvu, objektu un resursu veidi nav skalāri.

// skalāri define("FOO", 10); define("FOO", 10.9); define("FOO", "val"); define("FOO", patiess); // nav skalāri define("FOO", masīvs(1)); // konstante nav iestatīta un mēs saņemam Warning define("FOO", (object) array(1)); // konstante nav iestatīta un mēs saņemam brīdinājumu

No PHP 5.3

Parādījās atslēgvārds const un tagad ar to var definēt arī konstanti.

Tomēr jūs nevarat norādīt mainīgo, funkciju vai kāda veida izteiksmi, bet jums ir jānodod skalārs “tieši”:

Const FOO = "val"; // nav kļūdu const FOO = $var; // Parsēšanas kļūda const FOO = home_url(); // Parsēšanas kļūda const FOO = 5 + 10; // Parsēšanas kļūda const FOO = "foo"."bar"; // Parsēšanas kļūda

Tā kā define() šādu ierobežojumu nav...

Define("FOO", "val"); // nav kļūdu define("FOO", $var); // nav kļūdu define("FOO", home_url()); // nav kļūdu define("FOO", 5 + 10); // nav kļūdu define("FOO", "foo"."bar"); // bez kļūdām

PHP 5.6

Ir kļuvis iespējams norādīt primitīvas PHP izteiksmes (izteiksmes no skalāriem) kā const vērtības:

Const FOO = 1 + 2; const FOO = "foo" . "bārs";

Ir kļuvis iespējams saglabāt masīvus konstantēs:

Const FOO = ; // darbojas define("FOO", ); // nedarbojas PHP 5.6, darbojas PHP 7.0

Atšķirība starp define() un const

#1 const ir jādeklarē augšējā tvērumā

Atšķirībā no define() , const ir jādeklarē tvēruma pašā augšpusē, jo tie tiek definēti, kad tiek kompilēts skripts. Tas nozīmē, ka tos nevar deklarēt funkciju/cilpu/if priekšrakstos vai try/catch blokos.

If (1) ( const NOSAUKUMS = "VALUE"; // nedarbojas ) // bet if (1) ( define ("NAME", "VALUE"); // darbojas )

#2 const vienmēr ir reģistrjutīgs

Const vienmēr ir reģistrjutīgs, savukārt define () ļauj izveidot konstantes, kas nav reģistrjutīgas:

Define("NAME", "VALUE", true); atbalss NOSAUKUMS; // VALUE atbalss nosaukums; // VĒRTĪBA

#3 const saprot tikai skalārus

Tas ir spēkā tikai PHP versijām 5.6 un jaunākām...

const nevar nodot mainīgajiem, funkcijām, izteiksmēm, bet define () var būt:

Const FOO = $var; // Parsēšanas kļūda const FOO = home_url(); // Parsēšanas kļūda define("FOO", $var); // nav kļūdu define("FOO", home_url()); // bez kļūdām

#4 const var saglabāt masīvus kopš PHP 5.6 un definēt kopš PHP 7.0

const FOO = ; // darbojas PHP 5.6 define("FOO", ); // nedarbojas PHP 5.6, darbojas PHP 7.0

Salīdzināšanas rezultāti

Gandrīz vienmēr ir labāk definēt konstanti, izmantojot define() , jo ir vairāk iespēju un mazāk iespēju "noķert" kļūdu... Izņēmums ir gadījumi, kad jums ir PHP 5.6 un jums ir jāsaglabā masīvs konstantē, const šeit palīdzēs.

PHP klases konstantes

Tie tiek deklarēti tikai izmantojot const . Noteikumi tiem ir tādi, kā aprakstīts iepriekš: viņi pieņem tikai skalārus, nesaprot PHP mainīgos, funkcijas, izteiksmes...

Klases konstantes vienmēr ir publiskas – nav privāta vai aizsargāta statusa.

Deklarētā konstante pieder specifiski klasei, tā nepieder nevienam objektam un ir kopīga visiem klases objektiem (instancēm).

Klase My_Class ( const NOSAUKUMS = "VĒRTĪBA"; // sākot ar PHP 5.6 varat izmantot matemātiskās izteiksmes const SEC_PER_DAY = 60 * 60 * 24; funkcija print_name() ( // piekļūstot klases konstantei metodes iekšpusē, izmantojot self (pašu klasi ) echo self ::NAME; ) ) // piekļuvi konstantei ārpus klases // var izsaukt no globālā tvēruma, neinicializējot klases gadījumu echo My_Class::NAME;

Klases konstantes ir ļoti līdzīgas statiskās klases īpašībām.

Class My_Class ( const NOSAUKUMS = "VALUE"; statisks $nosaukums = "VALUE";; ) echo My_Class::NAME; echo My_Class::$name;

"Maģiskās" konstantes

Un noslēgumā atcerēsimies par īpašām PHP konstantēm...

PHP ir deviņas maģiskās konstantes, kas maina savu nozīmi atkarībā no konteksta, kurā tās tiek izmantotas. Piemēram, __LINE__ vērtība ir atkarīga no skripta rindas, kurā ir norādīta šī konstante. Visas "maģiskās" konstantes tiek atrisinātas kompilēšanas laikā, atšķirībā no parastajām konstantēm, kuras tiek atrisinātas izpildes laikā. Īpašās konstantes nav reģistrjutīgas, un tās ir norādītas tālāk:

Pastāvīgi	Apraksts
__LINE__	Pašreizējais rindas numurs failā.
__FILE__	Pašreizējā faila, kurā tiek izsaukta konstante, pilns ceļš un nosaukums.
__DIR__	PHP 5.3.0. Faila direktorijs, kurā tiek izmantota konstante. Tāds pats kā dirname(__FILE__) . Tai nav beigu slīpsvītras, izņemot saknes direktorijā.
__FUNCTION__	Funkcijas nosaukums.
__KLASE__	Klases nosaukums. Šis nosaukums satur tās nosaukumvietas nosaukumu, kurā klase tika deklarēta (piemēram, Foo\Bar). Darbojas arī īpašībās. Lietojot pazīmju metodēs, tas ir tās klases nosaukums, kurā šīs metodes tiek izmantotas.
__TRAIT__	PHP 5.4.0. Iezīmes nosaukums. Šajā nosaukumā ir ietverts tās nosaukumvietas nosaukums, kurā pazīme tika deklarēta (piemēram, Foo\Bar).
__METODE__	Klases metodes nosaukums.
__NAMESPACE__	PHP 5.3.0. Pašreizējās nosaukumvietas nosaukums.
Klases nosaukums::klase	PHP 5.5.0. Pilns klases nosaukums (ieskaitot nosaukumvietu). Skatīt arī::klase.