Rozdział 13. Stałe

Spis treści
Składnia
Predefiniowane stałe

Stała jest identyfikatorem (nazwą) dla prostej wartości. Jak sama nazwa wskazuje, wartość ta nie może się zmieniać podczas działania skryptu (poza wyjątkami: __FILE__ i __LINE__). Domyślnie, przy stałych uwzględniana jest wielkość liter. Przyjęto, że stałe są pisane dużymi literami.

Nazwa stałej podlega takim samym zasadom jak każda inna w PHP. Prawidłowa nazwa stałej rozpoczyna się literą, znakiem podkreślenia ("_"), następnie mogą występować litery, cyfry lub znaki podkreślenia. Dobrze reprezentuje to takie wyrażenie regularne: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*

Notatka: Na nasze potrzeby, litery to a-z, A-Z, oraz znaki ASCII od 127 do 255 (0x7f-0xff).

Zakres stałej jest globalny.

Składnia

Możesz definiować stałą używając funkcji define(). Kiedy stała zostanie zdefiniowana, nie może być już zmieniona albo undefined.

Tylko skalarne typy danych (boolean, integer, double i string) mogą być zawarte w stałych.

Możesz użyć wartości stałej poprzez zwykłe użycie jej nazwy. Inaczej niż przy zmiennych, w stałych NIE powinieneś prepend stałej znakiem $. Możesz także użyć funkcji constant(), aby odczytać wartość stałej, której nazwa jest przekazywana dynamicznie. Użyj funkcji get_defined_constants() aby otrzymać listę zdefiniowanych stałych.

Notatka: Stałe i globlane zmienne są pisane inaczej, a to oznacza, że np. TRUE i $TRUE są różne.

Jeśli użyjesz niezdefiniowanej stałej, PHP przyjmuje, że chcesz użyć nazwy stałej samej w sobie. Zostanie wtedy wysłane ostrzeżenie. Użyj funkcji defined() jeśli chcesz się dowiedzieć czy stała jest zdefiniowana.

Różnice pomiędzy stałymi, a zmiennymi:

Stałe nie mają znaku dolara ($) przed nazwą;
Stałe mogą być definiowane oraz używane wszędzie bez zważania na zasady dotyczące zakresu ich dostępności;
Stałe nie mogą być redefiniowane lub undefined po tym jak raz zostały zdefiniowane; i
Stałe mogą zawierać tylko wartości skalarne.

Przykład 13-1. Definiowanie stałych


<?php

define("STALA", "Hello world!");

echo STALA; // wyświetli "Hello world!"

echo Stala; // wyświetli "Stala" i zgłosi ostrzeżenie

?>

User Contributed Notes


Being a belt and suspenders person, when I use a constant to do flow control (i.e., using constants to determine which version of a section of the program should be used), I always use something like:



if ( defined('DEBUG') && TRUE===DEBUG )



If you accidentally use DEBUG somewhere before it is defined, PHP will create a new constant called DEBUG with the value 'DEBUG'. Adding the second comparison will prevent the expression from being TRUE when you did not intentionally create the constant. For the constant DEBUG, this would rarely be a problem, but if you had (e.g.) a constant used to determine whether a function was created using case-sensitive comparisons, an accidental creation of the constant IGNORE_CASE having the value 'IGNORE_CASE' could drive you up the wall trying to find out what went wrong, particularly if you had warnings turned off.



In almost all code I write, I put this function definition in my configuration section:



if (!function_exists("debug_print")) {

  if ( defined('DEBUG') && TRUE===DEBUG ) {

    function debug_print($string,$flag=NULL) {

      /* if second argument is absent or TRUE, print */

      if ( !(FALSE===$flag) )

        print 'DEBUG: '.$string . "\n";

    }

  } else {

    function debug_print($string,$flag=NULL) {

    }

  }

}



Then, in my code, I'll sprinkle liberal doses of debug code like :



define("DEBUG_TRACK_EXAMPLE_CREATION",FALSE);

class Example extends Something {

  __construct($whatever) {

    debug_print( "new instance of Example created with '$whatever'\n",DEBUG_TRACK_EXAMPLE_CREATION);

  }

}



and :



debug_print("finished init.\n")



In the first case, I would not want to see that message every time I went into DEBUG mode, so I made it a special case. The second case is always printed in DEBUG mode. If I decide to turn everything on, special cases and all, all I have to do is comment out the "if" line in debug_print() and presto magicko! It costs a little and gains a lot.



As another belt-and-suspenders aside, notice that, unlike most people, I put the language constant (e.g.,TRUE, "string", etc.) on the left side of the comparison. By doing that, you can never accidentally do something like 

  if ( $hard_to_find_error="here" )



because you always write it as 

  if ( "here"==$no_error )



or, if you got it wrong,

  if ( "here"=$easy_to_find_parse_error )


It is so easy to create a constant that the php novice might do so accidently while attempting to call a function with no arguments.  For example:

<?php

function LogoutUser(){

// destroy the session, the cookie, and the session ID

  blah blah blah;

  return true;

}

function SessionCheck(){

  blah blah blah;

// check for session timeout

...

    if ($timeout) LogoutUser;  // should be LogoutUser();

}

?>



OOPS!  I don't notice my typo, the SessionCheck function

doesn't work, and it takes me all afternoon to figure out why not!



<?php

LogoutUser;

print "new constant LogoutUser is " . LogoutUser;

?>


Re: Storm.

I ran that code (in PHP4)

<?php

if (DEBUG) {

   // echo some sensitive data.

}

?>

 and saw this warning:

"Use of undefined constant DEBUG - assumed 'DEBUG'"



A clearer workaround is to use

<?php

if (defined('DEBUG')) {

   // echo some sensitive data.

}

?>

Thanks for pointing out this big gotcha.



Another reason to turn on warnings during testing.  Good web servers are set up to suppress warning and error output to the browser, so this is handy:

<?php

if (defined('DEBUG')) {

  error_reporting(E_ALL);

  set_error_handler('debug_ErrorHandler');

}

function debug_ErrorHandler($errno, $errstr, $errfile, $errline) {

  print("PHP Error [$errno] [$errstr] at $errline in $errfile.<br>");

}

?>


PHP Modules also define constants.  Make sure to avoid constant name collisions.  There are two ways to do this that I can think of.

First: in your code make sure that the constant name is not already used.  ex. <?php if (! defined("CONSTANT_NAME")) { Define("CONSTANT_NAME","Some Value"); } ?>  This can get messy when you start thinking about collision handling, and the implications of this.

Second: Use some off prepend to all your constant names without exception  ex. <?php Define("SITE_CONSTANT_NAME","Some Value"); ?>



Perhaps the developers or documentation maintainers could recommend a good prepend and ask module writers to avoid that prepend in modules.


An undefined constant evaluates as true when not used correctly. Say for example you had something like this:



settings.php

<?php

// Debug mode

define('DEBUG',false);

?>



test.php

<?php

include('settings.php');



if (DEBUG) {

   // echo some sensitive data.

}

?>



If for some reason settings.php doesn't get included and the DEBUG constant is not set, PHP will STILL print the sensitive data. The solution is to evaluate it. Like so:



settings.php

<?php

// Debug mode

define('DEBUG',0);

?>



test.php

<?php

include('settings.php');



if (DEBUG == 1) {

   // echo some sensitive data.

}

?>



Now it works correctly.


To clarify from the previous post:



When you define a constant, it becomes fixed at that point and is immutable. You can add variables - but the constant becomes the contents of that variable when the define is evaluated. If you try:



define( "_A_TEXT" , "The value is " . $arr[$i] );



It would be evaluated ONCE with the current value of the $i index of array $arr. As the post pointed out, this is probably not what you want. You can easily create:



define( "_A_TEXT" , "The value is ");

....

echo _A_TEXT . $arr[$i];



Which would give you what you wanted: the constant string with the contents of the array appended.


I'm currently working on a site that has got to have two languages, and I wanted to use define's in functions to make everything simpler.



However, I ran into a problem. PHP doesn't recognize the variable in:

define("constantName", "This is an array variable - {$array[$i][2]}");



I can't use that in a for cycle, like I wanted to:



for ($i = 0; $i < count($array); $i++) {

echo constantName . "<br />"

}



The method I found (I think it's been mentioned before) is to:



define("constantName", "This is an array variable - %s");



And then:



for ($i = 0; $i < count($array); $i++) {

printf(constantName, $array[$i][2]);

}


before embarking on creating a language system I wanted to see if there was any speed advantage to defining language strings as constants vs. variables or array items.  It is more logical to define language strings as constants but you have more flexibility using variables or arrays in your code (i.e. they can be accessed directly, concatenated, used in quotes, used in heredocs whereas constants can only be accessed directly or concatenated).



Results of the test:

declaring as $Variable is fastest

declaring with define() is second fastest

declaring as $Array['Item'] is slowest



=======================================

the test was done using PHP 4.3.2, Apache 1.3.27, and the ab (apache bench) tool.

100 requests (1 concurrent) were sent to one php file that includes 15 php files each containing 100 unique declarations of a language string.



Example of each declaration ("Variable" numbered 1 - 1500):

<?php

$GLOBALS['Variable1'] = "A whole lot of text for this variable as if it were a language string containing a whole lot of text";

?>

<?php

define('Variable1' , "A whole lot of text for this variable as if it were a language string containing a whole lot of text");

?>

<?php

$GLOBALS['CP_Lang']['Variable1'] = "A whole lot of text for this variable as if it were a language string containing a whole lot of text";

?>



Here are the exact averages of each ab run of 100 requests (averages based on 6 runs):

variable (24.956 secs)

constant (25.426 secs)

array (28.141)



(not huge differences but good to know that using variables won't take a huge performance hit)


I find using the concatenation operator helps disambiguate value assignments with constants. For example, setting constants in a global configuration file:



define('LOCATOR',   "/locator");

define('CLASSES',   LOCATOR."/code/classes");

define('FUNCTIONS', LOCATOR."/code/functions");

define('USERDIR',   LOCATOR."/user");



Later, I can use the same convention when invoking a constant's value for static constructs such as require() calls:



require_once(FUNCTIONS."/database.fnc");

require_once(FUNCTIONS."/randchar.fnc");



as well as dynamic constructs, typical of value assignment to variables:



$userid  = randchar(8,'anc','u');

$usermap = USERDIR."/".$userid.".png";



The above convention works for me, and helps produce self-documenting code.



-- Erich


Late reply to fmmarzoa at gmx dot net: You're better off using sprintf format and defining your strings like this:



define('strArticleDescr', 'Published by %1$s on %2$s in %2$s');



It's more standard than what you're doing. Then instead of outputting it using an eval, do this:



echo sprintf(strArticleDescr, $article_author, $article_date, $article_lang_name');



And even better for i18n and l10n, don't use defines; use gettext. See the PHP manual section on gettext and the GNU gettext website. Gettext requires some modification of the way you think about strings but I find it worthwhile to make that adjustment.