ReflectionClass::getConstants()

(PHP 5, PHP 7)

获取一组常量

说明

publicReflectionClass::getConstants(void): array

获取某个类的全部已定义的常量，不管可见性如何定义。

Warning

本函数还未编写文档，仅有参数列表。

参数

此函数没有参数。

返回值

常量的数组，常量名是数组的键，常量的值是数组的值。

参见

• ReflectionClass::getConstant() 获取定义过的一个常量

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();
  }
}
?>

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'

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

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

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!

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