constant

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

constant — Bir sabitin değerini döndürür

Açıklama

constant(string $isim): mixed

isim ile ismi belirtilen sabitin değerini döndürür.

constant() işlevi ismini bilmediğiniz (bir değişkende saklanmış veya bir işlevden dönmüş) bir sabitin değerini döndürmek için kullanılabilir.

Bu işlev ayrıca, sınıf sabitleri ve sayılama kılıfları ile de çalışır.

Bağımsız Değişkenler

isim: Sabitin ismi.

Dönen Değerler

Sabitin değeri döner.

Hatalar/İstisnalar

Sabit tanımlı değilse Error istisnası oluşur. PHP 8.0.0 öncesinde böyle bir durumda E_WARNING seviyesinde bir hata üretilirdi.

Sürüm Bilgisi

Sürüm:	Açıklama
8.0.0	Sabir tanımlanmamışsa, constant() işlevi artık Error istisnası yavruluyor; evvelce `E_WARNING` seviyesinde bir hata üretilir ve `null` dönerdi.

Örnekler

Örnek 1 - constant() işlevinin sabitlerle kullanımı

<?php

define("MAXSIZE", 100);

echo MAXSIZE;
echo constant("MAXSIZE"); // Önceki satırla aynı.


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!"

?>

Örnek 2 - constant() işlevinin sayılama kılıfları ile kullanımı ( PHP 8.1.0 ve üstü)

<?php

enum Suit
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;
}

$case = 'Hearts';

var_dump(constant('Suit::'. $case)); // enum(Suit::Hearts)

?>

Ayrıca Bakınız

define() - Bir isimli sabit tanımlar
defined() - Belirtilen isimde sabit tanımlı mı diye bakar
get_defined_constants() - Tüm sabitlerin isimlerini ve değerlerini içeren bir ilişkisel dizi döndürür
Sabitler bölümü

Improve This Page

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 16 notes

down

Joachim Kruyswijk ¶

20 years ago

The constant name can be an empty string.

Code:

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

Output:

foo

down

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)

down

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'
?>

down

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.

down

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.

down

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;

}

?>

down

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.

down

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
?>

down

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

down

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

?>

down

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.

down

-2

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!';
}

?>

down

-2

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)

down

-2

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

down

-4

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.

down

-3

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$

＋add a note