PHP 8.3.4 Released!

ReflectionClass::getConstants

(PHP 5, PHP 7, PHP 8)

ReflectionClass::getConstantsGets constants

Beschreibung

public ReflectionClass::getConstants(?int $filter = null): array

Gets all defined constants from a class, regardless of their visibility.

Parameter-Liste

filter

The optional filter, for filtering desired constant visibilities. It's configured using the ReflectionClassConstant constants, and defaults to all constant visibilities.

Rückgabewerte

An array of constants, where the keys hold the name and the values the value of the constants.

Changelog

Version Beschreibung
8.0.0 filter has been added.

Siehe auch

add a note

User Contributed Notes 6 notes

up
44
davide dot renzi at gmail dot com
9 years ago
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();
}
}
?>
up
15
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'
up
13
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"
}

?>
up
1
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
}
}
?>
up
4
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!
up
0
dmitrochenkooleg at gmail dot com
4 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
To Top