If you want to return the constants defined inside a class then you can also define an internal method as follows:
<?php
class myClass {
const NONE = 0;
const REQUEST = 100;
const AUTH = 101;
// others...
static function getConstants() {
$oClass = new ReflectionClass(__CLASS__);
return $oClass->getConstants();
}
}
?>
ReflectionClass::getConstants
(PHP 5, PHP 7, PHP 8)
ReflectionClass::getConstants — Gets constants
Descrizione
Gets all defined constants from a class, regardless of their visibility.
Elenco dei parametri
-
filter -
The optional filter, for filtering desired constant visibilities. It's configured using the ReflectionClassConstant constants, and defaults to all constant visibilities.
Valori restituiti
An array of constants, where the keys hold the name and the values the value of the constants.
Log delle modifiche
| Versione | Descrizione |
|---|---|
| 8.0.0 |
filter has been added.
|
add a note
User Contributed Notes 6 notes
davide dot renzi at gmail dot com ¶
10 years ago
Sandor Toth ¶
7 years ago
You can pass $this as class for the ReflectionClass. __CLASS__ won't help if you extend the original class, because it is a magic constant based on the file itself.
<?php
class Example {
const TYPE_A = 1;
const TYPE_B = 'hello';
public function getConstants()
{
$reflectionClass = new ReflectionClass($this);
return $reflectionClass->getConstants();
}
}
$example = new Example();
var_dump($example->getConstants());
// Result:
array ( size = 2)
'TYPE_A' => int 1
'TYPE_B' => (string) 'hello'
Panni ¶
5 years ago
If you want to define a static getConstants() function which works with inheritance you can do the following:
<?php
abstract class AbstractClass
{
const TEST = "test";
public static function getConstants()
{
// "static::class" here does the magic
$reflectionClass = new ReflectionClass(static::class);
return $reflectionClass->getConstants();
}
}
class ChildClass extends AbstractClass
{
const TYPE_A = 1;
const TYPE_B = 'hello';
}
$example = new ChildClass();
var_dump($example->getConstants());
// Result:
array(3) {
'TYPE_A' => int(1)
'TYPE_B' => string(5) "hello"
'TEST' => string(4) "test"
}
?>
shgninc at gmail dot com ¶
10 years ago
I use a functions to do somthing base on the class constant name as below. This example maybe helpful for everybody.
<?php
public function renderData($question_type = NULL, $data = array()) {
$types = array();
$qt = new ReflectionClass(questionType);
$types = $qt->getConstants();
if ($type = array_search($question_type, $types)){
//.....Do somthing
}
}
?>
djhob1972 at yahoo dot com dot au ¶
14 years ago
I was trying to determine how to get a var_dump of constants that are within an interface. Thats right, not using any classes but the interface itself.
Along my travels I found it quite interesting that the ReflectionClass along with a direct call to the interface will also dump its constants. Perfect!!!!
This was using PHP 5.3.1 and my example as below:-
1st File:
constants.php
<?php
<?php>
interface MyConstants
{
// --------------------------
// Programmatic Level
// --------------------------
const DEBUG_MODE_ACTIVE = FALSE;
const PHP_VERSION_REQUIREMENT = "5.1.2";
}
?>
=======
Second file:
=======
test.php
<?php>
include_once ("constants.php");
$oClass = new ReflectionClass ('MyConstants');
$array = $oClass->getConstants ();
var_dump ($array);
unset ($oClass);
?>
what you would get from the command line:-
?:\???\htdocs\????>php test.php
array(2) {
["DEBUG_MODE_ACTIVE"]=> bool(false)
["PHP_VERSION_REQUIREMENT"]=> string(5) "5.1.2"
But as you can see this can work quite well to your advantage in many ways so I truely hope this helps someone else with a similar headache in the future to come!
Enjoy!
dmitrochenkooleg at gmail dot com ¶
5 years ago
Get the latest constants declared.
abstract class AbstractEnum
{
/**
* Возвращает все константы класса || Return all constants
*
* @return array
*/
static function getConstants()
{
$rc = new \ReflectionClass(get_called_class());
return $rc->getConstants();
}
/**
* Возвращает массив констант определенные в вызываемом классе || Return last constants
*
* @return array
*/
static function lastConstants()
{
$parentConstants = static::getParentConstants();
$allConstants = static::getConstants();
return array_diff($allConstants, $parentConstants);
}
/**
* Возвращает все константы родительских классов || Return parent constants
*
* @return array
*/
static function getParentConstants()
{
$rc = new \ReflectionClass(get_parent_class(static::class));
$consts = $rc->getConstants();
return $consts;
}
}
======
class Roles extends AbstractEnum
{
const ROOT = 'root';
const ADMIN = 'admin';
const USER = 'user';
}
// Output:
All: root, admin, user
Last: root, admin, user
class NewRoles extends Roles
{
const CLIENT = 'client';
const MODERATOR = 'moderator';
const SUPERMODERATOR = 'super'.self::USER;
}
// Output:
All: client, moderator, superuser, root, admin, user
Last: client, moderator, superuser
class AdditionalRoles extends Roles
{
const VIEWER = 'viewer';
const CHECKER = 'checker';
const ROOT = 'rooter';
}
All: viewer, checker, rooter, client, moderator, superuser, admin, user
Last: viewer, checker, rooter
