defined

constant

Last updated: Fri, 18 Jul 2008

define

(PHP 4, PHP 5)

define — Defines a named constant

Description

bool define ( string $name , mixed $value [, bool $case_insensitive ] )

Defines a named constant at runtime.

Parameters

name: The name of the constant.
value: The value of the constant; only scalar and null values are allowed. Scalar values are integer, float, string or boolean values.
case_insensitive: If set to TRUE, the constant will be defined case-insensitive. The default behaviour is case-sensitive; i.e. CONSTANT and Constant represent different values.

Return Values

Returns TRUE on success or FALSE on failure.

Examples

Example #1 Defining Constants


<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // outputs "Hello world."
echo Constant; // outputs "Constant" and issues a notice.

define("GREETING", "Hello you.", true);
echo GREETING; // outputs "Hello you."
echo Greeting; // outputs "Hello you."

?>


How to define an array as constant with define?



there is a simple way to define an array of values as constant...



just 



define ("constant-name","value1,value2,value3,value4");



$t_array = preg_split('/,/', constant(constant-name), -1, PREG_SPLIT_NO_EMPTY);



var_dump($t_array);



array(4) { [0]=> string(6) "value1" [1]=> string(6) "value2" [2]=> string(6) "value3" [3]=> string(6) "value4" } 



Now you can iterate over the array defined as constant ...

ceo at l-i-e dot com
05-May-2008 05:30


I'm not sure if it's version dependent, but apparently this works:

define('APPLICATION_NOW', time());



This can be quite handy for time-dependent code...



You can then do:

class foo {

  $private now = APPLICATION_NOW;

}



and have a consistent time-stamp across the application, which is nice.



Works for me in 5.2.5



I didn't think it worked before...

jason@sitehatchery dot com
25-Apr-2008 08:28


You can store your constant as the value of a variable like this:



$variable=VARIABLE;



To access the constant, do this:  constant($variable).



Beware: if your variable changes, then you loose your reference to the constant - but the constant itself will not change.



I've found this especially useful for storing the constant string   (i.e. VARIABLE) in a database.

rayro at gmx dot de
15-Sep-2007 11:53


just a note to the previous post by e s lin d sey at g mail dot co m:



Well as u said, it is not the best workaround. To resolve this "Problem" without getting incredible loss of performance, you are able to make the use of "variable functions" like "variable variables":



<?php

$def = 'constant';

$string = <<<END

    This is PHP running on<br />

    {$def('PHP_OS')}

END;

var_dump($string);

?>



In this example we make use of the "constant" function which is builtin, and it will output:



string(37) " This is PHP running on

WINNT"



Tested on PHP 5...

Best regards

e s lin d sey at g mail dot co m
13-Aug-2007 10:38


Constants can't be referenced from within quotes or (more importantly IMHO) from within HEREDOC syntax. This is a huge drawback in my opinion. Here's two of my workarounds:



<?php



//PHP5 only -- more efficient

$constarray = get_defined_constants(true);

foreach($constarray['user'] as $key => $val)

    eval(sprintf('$_CONSTANTS[\'%s\'] = \'%s\';', addslashes($key), addslashes($val)));



//PHP4+ -- less efficient because it defines (potentially) hundreds of unnecessary constants

foreach(get_defined_constants() as $key => $val)

    eval(sprintf('$_CONSTANTS[\'%s\'] = \'%s\';', addslashes($key), addslashes($val)));



?>



Now you can refer to your defined constants using the $_CONSTANTS array. Note that because this is NOT a superglobal, a few caveats apply:



<?php



//run code snippet here to define $_CONSTANTS in global scope...



$mv = $_CONSTANTS['FOO']; //works



function my_function1()

{

    $mv = $_CONSTANTS['BAR']; //doesn't work! not defined!

}



function my_function2()

{

    global $_CONSTANTS;

    $mv = $_CONSTANTS['BAR']; //ah, this works!

}



?>



I realize this is not ideal, either for performance or for convenience of being able to refer to constants without regard to scope, but it is a workaround that works. Depending on your application, it may be easier to shift your paradigm a bit and use the following method instead, declaring your constants as variables first:



<?php



//first, define our constants...

$_CONSTANTS['FOO'] = 'bar';

$_CONSTANTS['BAR'] = 'foo';



//now, turn them into real constants...

foreach($_CONSTANTS as $key => $val)

    define($key, $val);



//now, you can use either format to refer to a constant

print($_CONSTANTS['FOO']);   //prints 'bar'

print(FOO);                  //prints 'bar'

print("$_CONSTANTS['FOO']"); //prints 'bar'

                             //prints 'blah bar blah'

print <<<EOF

  blah {$_CONSTANTS['FOO']} blah

EOF;



?>



Hope this helps some of you out there, I know being able to utilize my constants in HEREDOC helped me a ton!

smifffy at smith-net dot org dot uk
26-Jul-2007 01:23


a basic function to auto assign a numeric value that increase by itself each time - used in some permission style scripts



<?php

function define_bitwise($constant_name, $reset = False)

{

    static $bitwise_next = 1;



    if ( $reset === True )

    {

        $bitwise_next = 1;

    }



    define($constant_name, $bitwise_next);

        

    $bitwise_next += $bitwise_next;

}

?>



when reset it set to True, resets that value to 1 and starts afresh

creeves at dja dot com
19-Jul-2007 03:59


Intersting to note:



I found this in php5 on windows 



If you try to unset a constant (which you cant but maybe you have a Jr. programmer or something).  The error message that is thrown is:



<?php

define ("SOME_CONSTANT", true);

unset (SOME_CONSTANT);

?>



Parse error: parse error, unexpected ')', expecting T_PAAMAYIM_NEKUDOTAYIM

nl-x at bita dot nl
09-Jul-2007 07:34


Watch out. You can define a new constant with the name NULL with define("NULL","FOO");. But you must use the function constant("NULL"); to get it's value. NULL without the function call to the constant() function will still retrieve the special type NULL value.

Within a class there is no problem, as const NULL="Foo"; will be accessible as myClass::NULL.

stangelanda at arrowquick dot com
01-Jan-2007 03:59


An improvement on the function from bobbykjack at yahoo dot co dot uk on the concept by richard dot quadling at bandvulc dot co dot uk:

<?php

function adefine($constant_name, $value=null) {

    static $increment = 0; // 1 for bitmask



    if (is_null($value)) {

        define($constant_name, ++$increment); // $increment=$increment<<1 for bitmask

    } else {

        define($constant_name, $value);

        if (is_numeric($value)) {

            $increment = $value;

        }

    }

}

?>

If you pass it a second argument it defines it normally, and resets the increment if the value is numeric.  This way the function can replace define, and you can reset the counter for a new set of constants.

<?php

adefine ('RULE_CALLBACK_FORMAT', 1); // 1

adefine ('RULE_CHANGE_CALLBACK_ON_ERROR'); // 2

adefine ('RULE_CHANGE_COMPARE_DATE'); // 3

adefine('KEYWORD', 'hodgepodge'); // hodgepodge <-- defined normally

adefine ('RULE_CHANGE_ON_DATE'); // 4



adefine ('ERROR_DESC', 1); // 1 <-- Counter reset

adefine ('ERROR_EXPECTED_RESULT'); // 2

?>

12-Feb-2005 05:45


Better pack with define() for all who really miss Java package management:



Use this "manifest.php" on very first script start or copy it to your config.somehow.php.



<?php

$__packages = array(

    "org.ilove.java.more",

    "org.ilove.python.too",

    "net.php.isok"

);



define("C_IS_WINDOWS", false);

define("C_DIR", (C_IS_WINDOWS ? "\\" : "/"));

define("C_PATH_ROOT", str_replace("/", C_DIR, $_SERVER["DOCUMENT_ROOT"]).C_DIR);

define("C_PATH_CORE", C_PATH_ROOT."core".C_DIR);

define("C_PATH_CLASS", C_PATH_CORE."classes".C_DIR);

define("C_APPLICATION_BASE", C_PATH_CORE.C_DIR."application".C_DIR);



$total_packages = 0;

$i = sizeof($__packages);

while($i-- > 0) {

    $tokens = explode(".", $__packages[$i]);

    $j = sizeof($tokens);

    while($j-- > 0) {

        $token = strtolower(trim($tokens[$j]));

        if(strlen($token) > 0 && !defined($token)) {

            define($token, ($j == 0 ? C_PATH_CLASS : "").$tokens[$j].C_DIR);

            $total_packages++;

        }

    }

}

define("C_PACKAGE_COUNT", $total_packages);

?>



With restrictions on non-package constants, you now can call your files like that:



<?php



require_once org.ilove.java.more."Than.php";



?>



Regards

Robi

phpnet at trenkner dot de
15-Mar-2003 12:59


---[Editor's Note]---


As of PHP 5.0.0 this is possible. You can define class-only constants, which can be called like Foo::Constant1 from the outside


---[End Note]---





Please keep in mind that 





class AClass {


  define ("Const1", "Value1");


  ... }





didn't work. You have to make all your constant definitions before you open the class. So





define ("Const1", "Value1");


class AClass {


  ... }





would be correct.

radovan dot biciste at managestar dot com
07-Nov-2001 05:45


Wonder how to work with variable which name is stored in a constant? 


Here it is:


<?php


define("VAR_NAME","test");


// assigning value


${VAR_NAME} = "value";


// getting value back


echo ${VAR_NAME};


?>

ste at opk dot no
29-Aug-2001 07:41


To use a constant to show an element of an array inside a string:


define ('C', 0); print ("element 0: {$a[C]}");


The { & } around the variable signals that what's inside should be treated as a variable and not a string.


Note that 'print ("a constant:{C}");' wont work as ZERO is a constant.

add a note