Edit Report a Bug

    constant

    (PHP 4 >= 4.0.4, PHP 5, PHP 7)

    constant — 상수 값을 반환합니다

    설명

    mixed constant ( string $name )

    name이 가리키는 상수 값을 반환합니다.

    constant()는 이름을 모르는 상수 값을 얻어올 때 유용합니다. 예를 들면, 변수에 저장되어 있거나, 함수로부터 반환되는 경우입니다.

    이 함수는 클래스 상수에도 동작합니다.

    인수

    name

    상수 이름.

    반환값

    상수의 값을 반환하거나, 상수가 정의되지 않았을 경우 NULL을 반환합니다.

    오류/예외

    상수가 정의되어 있지 않은 경우, E_WARNING 레벨 에러가 발생합니다.

    예제

    Example #1 constant() 예제

    <?php

    define    ("MAXSIZE", 100);

    echo     MAXSIZE;
    echo     constant("MAXSIZE"); // 바로 앞 라인과 동일합니다


    interface bar {
        const     test = 'foobar!';
    }

    class     foo {
        const     test = 'foobar!';
    }

    $const = 'test';

    var_dump(constant('bar::'. $const)); // string(7) "foobar!"
    var_dump(constant('foo::'. $const)); // string(7) "foobar!"

    ?>

    참고

    add a note add a note

    User Contributed Notes 17 notes

    up
    80
    Joachim Kruyswijk
    19 years ago
    The constant name can be an empty string.

    Code:

    define("", "foo");
    echo constant("");

    Output:

    foo
    up
    20
    t dot kmieliauskas at gmail dot com
    9 years ago
    If you are referencing class constant (either using namespaces or not, because one day you may want to start using them), you'll have the least headaches when doing it like this:

    <?php
    class Foo {
        const     BAR = 42;
    }
    ?>
    <?php
    namespace Baz;
    use \    Foo as F;

    echo     constant(F::class.'::BAR');
    ?>

    since F::class will be dereferenced to whatever namespace shortcuts you are using (and those are way easier to refactor for IDE than just plain strings with hardcoded namespaces in string literals)
    up
    9
    helvete at zhouba dot cz
    8 years ago
    It is worth noting, that keyword 'self' can be used for constant retrieval from within the class it is defined

    <?php
    class Foo {
      const     PARAM_BAR = 'baz';

      public function     getConst($name) {
        return     constant("self::{$name}");
      }
    }

    $foo = new Foo();
    echo     $foo->getConst('PARAM_BAR'); // prints 'baz'
    ?>
    up
    13
    Richard J. Turner
    11 years ago
    As of PHP 5.4.6 constant() pays no attention to any namespace aliases that might be defined in the file in which it's used. I.e. constant() always behaves as if it is called from the global namespace. This means that the following will not work:

    <?php
    class Foo {
        const     BAR = 42;
    }
    ?>

    <?php
    namespace Baz;

    use \    Foo as F;

    echo     constant('F::BAR');
    ?>

    However, calling constant('Foo::BAR') will work as expected.
    up
    8
    Trevor Blackbird > yurab.com
    18 years ago
    Technically you can define constants with names that are not valid for variables:

    <?php

    // $3some is not a valid variable name
    // This will not work
    $3some = 'invalid';

    // This works
    define('3some', 'valid');
    echo     constant('3some');

    ?>

    Of course this is not a good practice, but PHP has got you covered.
    up
    5
    Andre
    21 years ago
    Maybe this is useful:

    $file_ext is the file Extension of the image

    <?php
    if ( imagetypes() & @constant('IMG_' . strtoupper($file_ext)) )
    {
            $file_ext = $file_ext == 'jpg' ? 'jpeg' : $file_ext;
            $create_func = 'ImageCreateFrom' . $file_ext;
    }
    ?>
    up
    3
    XC
    17 years ago
    When you often write lines like

    <?php

    if(defined('FOO') && constant('FOO') === 'bar')
    {
    ...
    }

    ?>

    to prevent errors, you can use the following function to get the value of a constant.

    <?php

    function getconst($const)
    {
        return (    defined($const)) ? constant($const) : null;
    }

    ?>

    Finally you can check the value with

    <?php

    if(getconst('FOO') === 'bar')
    {
    ...
    }

    ?>

    It's simply shorter.
    up
    0
    hellekin
    14 years ago
    Checking if a constant is empty is bork...

    You cannot

    <?php
    define    ('A', '');
    define('B', 'B');

    if (empty(    B)) // syntax error
    if (empty(constant('B'))) // fatal error

    // so instead, thanks to LawnGnome on IRC, you can cast the constants to boolean (empty string is false)
    if (((boolean) A) && ((boolean) B))
          // do stuff
    ?>
    up
    -1
    narada dot sage at googlemail dot com
    18 years ago
    To access the value of a class constant use the following technique.

    <?php

    class a {
        const     b = 'c';
    }

    echo     constant('a::b');

    // output: c

    ?>
    up
    -1
    Anonymous
    19 years ago
    In reply to VGR_experts_exchange at edainworks dot com

    To check if a constant is boolean, use this instead:

    <?php
    if (TRACE === true)  {}
    ?>

    Much quicker and cleaner than using defined() and constant() to check for a simple boolean.

    IMO, using ($var === true) or ($var === false) instead of ($var) or (!$var) is the best way to check for booleans no matter what. Leaves no chance of ambiguity.
    up
    -1
    nikolays93 at ya dot ru
    4 years ago
    <?php

    namespace Foo;

    define(__NAMESPACE__ . '\Bar', 'its work'); // ..but IDE may make notice

    echo Bar; // its work
    up
    -3
    bohwaz
    14 years ago
    Return constants from an object. You can filter by regexp or match by value to find a constant name from the value.

    Pretty useful sometimes.

    <?php

    function findConstantsFromObject($object, $filter = null, $find_value = null)
    {
            $reflect = new ReflectionClass($object);
            $constants = $reflect->getConstants();
       
        foreach (    $constants as $name => $value)
        {
            if (!    is_null($filter) && !preg_match($filter, $name))
            {
                unset(    $constants[$name]);
                continue;
            }
           
            if (!    is_null($find_value) && $value != $find_value)
            {
                unset(    $constants[$name]);
                continue;
            }
        }
       
        return     $constants;
    }

    ?>

    Examples :

    <?php

    class Example
    {
        const     GENDER_UNKNOW = 0;
        const     GENDER_FEMALE = 1;
        const     GENDER_MALE = 2;

        const     USER_OFFLINE = false;
        const     USER_ONLINE = true;
    }

    $all = findConstantsFromObject('Example');

    $genders = findConstantsFromObject('Example', '/^GENDER_/');

    $my_gender = 1;
    $gender_name = findConstantsFromObject('Example', '/^GENDER_/', $my_gender);

    if (isset(    $gender_name[0]))
    {
            $gender_name = str_replace('GENDER_', '', key($gender_name));
    }
    else
    {
            $gender_name = 'WTF!';
    }

    ?>
    up
    -5
    adam at adamhahn dot com
    13 years ago
    This function is namespace sensitive when calling class constants.

    Using:
    <?php namespace sub;

    class     foo {
        const     BAR = 'Hello World';
    }

    constant('foo::BAR'); // Error

    constant('sub\foo::BAR'); // works

    ?>

    This does not seem to affect constants defined with the 'define' function. Those all end up defined in the root namespace unless another namespace is implicitly defined in the string name of the constant.
    up
    -3
    dachnik
    14 years ago
    You can define values in your config file using the names of your defined constants, e.g.

    in your php code:
    define("MY_CONST",999);

    in you config file:
    my = MY_CONST

    When reading the file do this:

    $my = constant($value); // where $value is the string "MY_CONST"

    now $my holds the value of 999
    up
    -3
    Anonymous
    5 years ago
    The use of constant() (or some other method) to ensure the your_constant was defined is particularly important when it is to be defined as either `true` or `false`. 

    For example, taken from this Stackoverflow Question 
    https://stackoverflow.com/questions/5427886/php-undefined-constant-testing/56604602#56604602)  

    If `BOO` did NOT get defined as a constant, for some reason,

        <?php if(BOO) do_something(); ?>

    would evaluate to `TRUE` and run anyway.  A rather unexpected result.   

    The reason is that PHP ASSUMES you "forgot" quotation marks around `BOO` when it did not see it in its list of defined constants.   
    So it evaluates: `if ('BOO')`...  
    Since every string, other than the empty string, is "truthy", the expression evaluates to `true` and the do_something() is run, unexpectedly. 

    If you instead use: 
         <?php if (constant(BOO)) do_something() ?> 

    then if `BOO` has not been defined, `constant(BOO)` evaluates to `null`, 
    which is falsey, and `if (null)`... becomes `false`, so do_something() is skipped, as expected.  

    The PHP behavior regarding undefined constants is particularly glaring when having a particular constant defined is the exception, "falsey" is the default, and having a "truthy" value exposes a security issue. For example,  
    <?php if (IS_SPECIAL_CASE) show_php_info() ?> . 

    There are other ways around this PHP behavior, such as  
    <?php if (BOO === true) do_something(); ?> 
    or 
    <?php if (defined('BOO') && BOO) do_something() ?>.  

    Note that only the version using `defined()` works without also throwing a PHP Warning  "error message."

    Here is a php repl.it demonstration:
    https://repl.it/@sherylhohman/php-undefined-constants-beware-of-truthy-conversion?language=php_cli&folderId=

    (disclosure: I also submitted an answer to the SO question linked to above)
    up
    -4
    mohammad alzoqaily
    7 years ago
    // 1)  you can store the name of constant in default variable
    //     and use it without identify it's name :)

            $str= "constName";
         
            define("constName","this is constant");

            echo constant($str);
          

           output:
                 this is constant

    // 2)  good for dynamic generating  constants
          

             function generateConst( $const ,  $value , $sensitivity=TRUE )
                 {
                 
                        define( "$const" , "$value ",$sensitivity);
                  }

                  $CONST="cost";
                  $VALUE="100$";
                 
                 generateConst( $CONST , $VALUE);
                             
                 echo constant($const);

            output:
                    100$
    up
    -6
    service at dual-creators dot de
    18 years ago
    It's easily to user constant() and define() to translate some words from your database-saves.

    For example:
    You have a table userprofil and one coloumn is "gender".
    Gender can be male or female but you will display "maennlich" or "weiblich" (german words for it - whatever...)

    First step: Fetch into $Gender

    Second:
    define("male", "maennlich");
    define("female", "weiblich");

    Third:
    echo constant($Gender);

    Now, the index of the variable $Gender will be handled like a constant!

    (It works like "echo male;" for better understanding)

    And a result of this, it displays maennlich btw. weiblich!

    greetz
    add a note add a note
    To Top