J'ai plusieurs CONST définis sur certaines classes et je veux en obtenir une liste. Par exemple:

class Profile {
    const LABEL_FIRST_NAME = "First Name";
    const LABEL_LAST_NAME = "Last Name";
    const LABEL_COMPANY_NAME = "Company";
}

Existe-t-il un moyen d'obtenir une liste des CONST définis sur la Profileclasse? Pour autant que je sache, l'option la plus proche ( get_defined_constants()) ne fera pas l'affaire.

Ce dont j'ai réellement besoin est une liste des noms constants - quelque chose comme ceci:

array('LABEL_FIRST_NAME',
    'LABEL_LAST_NAME',
    'LABEL_COMPANY_NAME')

Ou:

array('Profile::LABEL_FIRST_NAME', 
    'Profile::LABEL_LAST_NAME',
    'Profile::LABEL_COMPANY_NAME')

Ou même:

array('Profile::LABEL_FIRST_NAME'=>'First Name', 
    'Profile::LABEL_LAST_NAME'=>'Last Name',
    'Profile::LABEL_COMPANY_NAME'=>'Company')

Vous pouvez utiliser Reflection pour cela. Notez que si vous faites beaucoup cela, vous voudrez peut-être regarder la mise en cache du résultat.

<?php
class Profile {
    const LABEL_FIRST_NAME = "First Name";
    const LABEL_LAST_NAME = "Last Name";
    const LABEL_COMPANY_NAME = "Company";
}


$refl = new ReflectionClass('Profile');
print_r($refl->getConstants());

Production:

Array
(
    'LABEL_FIRST_NAME' => 'First Name',
    'LABEL_LAST_NAME' => 'Last Name',
    'LABEL_COMPANY_NAME' => 'Company'
)

Ce

 $reflector = new ReflectionClass('Status');
 var_dump($reflector->getConstants());

Utilisez token_get_all () . À savoir:

<?php
header('Content-Type: text/plain');

$file = file_get_contents('Profile.php');
$tokens = token_get_all($file);

$const = false;
$name = '';
$constants = array();
foreach ($tokens as $token) {
    if (is_array($token)) {
        if ($token[0] != T_WHITESPACE) {
            if ($token[0] == T_CONST && $token[1] == 'const') {
                $const = true;
                $name = '';
            } else if ($token[0] == T_STRING && $const) {
                $const = false;
                $name = $token[1];
            } else if ($token[0] == T_CONSTANT_ENCAPSED_STRING && $name) {
                $constants[$name] = $token[1];
                $name = '';
            }
        }
    } else if ($token != '=') {
        $const = false;
        $name = '';
    }
}

foreach ($constants as $constant => $value) {
    echo "$constant = $value\n";
}
?>

Production:

LABEL_FIRST_NAME = "First Name"
LABEL_LAST_NAME = "Last Name"
LABEL_COMPANY_NAME = "Company"

En PHP5, vous pouvez utiliser Reflection: (référence manuelle)

$class = new ReflectionClass('Profile');
$consts = $class->getConstants();

Selon les commentaires de la documentation PHP, si vous pouvez utiliser ReflectionClass (PHP 5):

function GetClassConstants($sClassName) {
    $oClass = new ReflectionClass($sClassName);
    return $oClass->getConstants();
}

La source est ici.

En utilisant ReflectionClass et getConstants()donne exactement ce que vous voulez:

<?php
class Cl {
    const AAA = 1;
    const BBB = 2;
}
$r = new ReflectionClass('Cl');
print_r($r->getConstants());

Production:

Array
(
    [AAA] => 1
    [BBB] => 2
)

Trait avec méthode statique - à la rescousse

On dirait que c'est un bon endroit pour utiliser des traits avec une fonction statique pour étendre les fonctionnalités de classe. Les traits nous permettront également d'implémenter cette fonctionnalité dans n'importe quelle autre classe sans réécrire le même code encore et encore (restez DRY).

Utilisez notre trait personnalisé 'ConstantExport' avec la classe Profile. Faites-le pour chaque classe pour laquelle vous avez besoin de cette fonctionnalité.

/**
 * ConstantExport Trait implements getConstants() method which allows 
 * to return class constant as an assosiative array
 */
Trait ConstantExport 
{
    /**
     * @return [const_name => 'value', ...]
     */
    static function getConstants(){
        $refl = new \ReflectionClass(__CLASS__);
        return $refl->getConstants();
    }
}

Class Profile 
{
    const LABEL_FIRST_NAME = "First Name";
    const LABEL_LAST_NAME = "Last Name";
    const LABEL_COMPANY_NAME = "Company";

    use ConstantExport;

}

EXEMPLE D'UTILISATION

// So simple and so clean
$constList = Profile::getConstants(); 

print_r($constList); // TEST

LES SORTIES:

Array
(
    [LABEL_FIRST_NAME] => First Name
    [LABEL_LAST_NAME] => Last Name
    [LABEL_COMPANY_NAME] => Company
)

Ouais, vous utilisez la réflexion . Regardez la sortie de

<?
Reflection::export(new ReflectionClass('YourClass'));
?>

Cela devrait vous donner une idée de ce que vous allez regarder.

Il est pratique d'avoir une méthode à l'intérieur de la classe pour renvoyer ses propres constantes.
Vous pouvez faire de cette façon:

class Profile {
    const LABEL_FIRST_NAME = "First Name";
    const LABEL_LAST_NAME = "Last Name";
    const LABEL_COMPANY_NAME = "Company";


    public static function getAllConsts() {
        return (new ReflectionClass(get_class()))->getConstants();
    }
}

// test
print_r(Profile::getAllConsts());

Pourquoi ne pas les mettre dans une variable de classe sous forme de tableau pour commencer? Facilite la lecture en boucle.

private $_data = array("production"=>0 ...);

Finalement avec des espaces de noms:

namespaces enums;
class enumCountries 
{
  const CountryAustria          = 1 ;
  const CountrySweden           = 24;
  const CountryUnitedKingdom    = 25;
}

namespace Helpers;
class Helpers
{
  static function getCountries()
  {
    $c = new \ReflectionClass('\enums\enumCountries');
    return $c->getConstants();
  }
}

print_r(\Helpers\Helpers::getCountries());

class Qwerty 
{
    const __COOKIE_LANG_NAME__ = "zxc";
    const __UPDATE_COOKIE__ = 30000;

    // [1]
    public function getConstants_(){

        return ['__COOKIE_LANG_NAME__' => self::__COOKIE_LANG_NAME__, 
                '__UPDATE_COOKIE__' => self::__UPDATE_COOKIE__]; 
    }    

    // [2]
    static function getConstantsStatic_(){

        return ['__COOKIE_LANG_NAME__' => self::__COOKIE_LANG_NAME__, 
                '__UPDATE_COOKIE__' => self::__UPDATE_COOKIE__]; 
    } 
}

// [1]
$objC = new Qwerty();
var_dump($objC->getConstants_());

// [2]
var_dump(Qwerty::getConstantsStatic_());