defined

constant

Last updated: Sat, 17 Jul 2004

define

(PHP 3, PHP 4 , PHP 5)

define -- Defines a named constant.

Description

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

Defines a named constant. See the section on constants for more details.

The name of the constant is given by name; the value is given by value.

The optional third parameter case_insensitive is also available. If the value TRUE is given, then the constant will be defined case-insensitive. The default behaviour is case-sensitive; i.e. CONSTANT and Constant represent different values.

�rnek 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."



?>

Returns TRUE on success or FALSE on failure.

See also defined(), constant() and the section on Constants.

defined

constant

Last updated: Sat, 17 Jul 2004

add a note User Contributed Notes
define

eparkerii at carolina dot rr dot com
22-Oct-2008 12:01


Found something interesting.  The following define:





<?php


define("THIS-IS-A-TEST","This is a test");


echo THIS-IS-A-TEST;


?>





Will return a '0'.





Whereas this:





<?php


define("THIS_IS_A_TEST","This is a test");


echo THIS_IS_A_TEST;


?>





Will return 'This is a test'.





This may be common knowledge but I only found out a few minutes ago.





[EDIT BY danbrown AT php DOT net: The original poster is referring to the hyphens versus underscores.  Hyphens do not work in defines or variables, which is expected behavior.]

pistachio
01-Sep-2008 04:41


A better solution to that of thscheer at web dot de, is to simply serialize the array.



for example:



<?php



$fruits = array("apple", "banana", "orange");



define("FRUITS", serialize($fruits));



// Now to use it

$my_fruits = unserialize(FRUITS);



?>



As you can see this is a much simpler and more efficient way to stuff arrays into constants.

jan at webfontein dot nl
27-Jul-2008 05:20


For translating with variables and define, take also a look on the constant() function.



Example : 



<?php 

define('PAYMENT_IDEAL',"iDEAL Payment ( NL only )");

define('PAYMENT_MASTERCARD',"Mastercard Payment ( international )");



$payparam='MASTERCARD';



echo constant("PAYMENT_$payparam");



// output : 

// Mastercard Payment ( international )

?>

thscheer at web dot de
20-Jun-2008 02:18


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 08: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
24-Apr-2008 11: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 02: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 01: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
25-Jul-2007 04: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 06: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 10: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
31-Dec-2006 06: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

?>

11-Feb-2005 08: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
14-Mar-2003 03: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
06-Nov-2001 08: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 10: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

defined

constant

Last updated: Sat, 17 Jul 2004