Constantes PHP contenant des tableaux?

Cela a échoué:

 define('DEFAULT_ROLES', array('guy', 'development team'));

Apparemment, les constantes ne peuvent pas contenir de tableaux. Quelle est la meilleure façon de contourner cela?

define('DEFAULT_ROLES', 'guy|development team');

//...

$default = explode('|', DEFAULT_ROLES);

Cela semble être un effort inutile.

REMARQUE: bien qu'il s'agisse de la réponse acceptée, il convient de noter qu'en PHP 5.6+, vous pouvez avoir des tableaux const - voir la réponse d'Andrea Faulds ci-dessous .

Vous pouvez également sérialiser votre baie puis la mettre dans la constante:

# define constant, serialize array
define ("FRUITS", serialize (array ("apple", "cherry", "banana")));

# use it
$my_fruits = unserialize (FRUITS);

Depuis PHP 5.6, vous pouvez déclarer une constante de tableau avec const:

<?php
const DEFAULT_ROLES = array('guy', 'development team');

La syntaxe courte fonctionne également, comme vous pouvez vous y attendre:

<?php
const DEFAULT_ROLES = ['guy', 'development team'];

Si vous avez PHP 7, vous pouvez enfin utiliser define(), comme vous l'aviez d'abord essayé:

<?php
define('DEFAULT_ROLES', array('guy', 'development team'));

Vous pouvez les stocker en tant que variables statiques d'une classe:

class Constants {
    public static $array = array('guy', 'development team');
}
# Warning: array can be changed lateron, so this is not a real constant value:
Constants::$array[] = 'newValue';

Si vous n'aimez pas l'idée que le tableau puisse être modifié par d'autres, un getter pourrait vous aider:

class Constants {
    private static $array = array('guy', 'development team');
    public static function getArray() {
        return self::$array;
    }
}
$constantArray = Constants::getArray();

ÉDITER

Depuis PHP5.4, il est même possible d'accéder aux valeurs des tableaux sans avoir besoin de variables intermédiaires, c'est-à-dire les travaux suivants:

$x = Constants::getArray()['index'];

Si vous utilisez PHP 5.6 ou supérieur, utilisez la réponse d'Andrea Faulds

Je l'utilise comme ça. J'espère que cela aidera les autres.

config.php

class app{
    private static $options = array(
        'app_id' => 'hello',
    );
    public static function config($key){
        return self::$options[$key];
    }
}

En dossier, où j'ai besoin de constantes.

require('config.php');
print_r(app::config('app_id'));

C'est ce que j'utilise. Il est similaire à l'exemple fourni par soulmerge, mais de cette façon, vous pouvez obtenir le tableau complet ou juste une seule valeur dans le tableau.

class Constants {
    private static $array = array(0 => 'apple', 1 => 'orange');

    public static function getArray($index = false) {
        return $index !== false ? self::$array[$index] : self::$array;
    }
}

Utilisez-le comme ceci:

Constants::getArray(); // Full array
// OR 
Constants::getArray(1); // Value of 1 which is 'orange'

Vous pouvez le stocker sous forme de chaîne JSON dans une constante. Et du point de vue de l'application, JSON peut être utile dans d'autres cas.

define ("FRUITS", json_encode(array ("apple", "cherry", "banana")));    
$fruits = json_decode (FRUITS);    
var_dump($fruits);

À partir de PHP 5.6, vous pouvez définir des tableaux constants à l'aide de constmots clés comme ci-dessous

const DEFAULT_ROLES = ['test', 'development', 'team'];

et différents éléments sont accessibles comme ci-dessous:

echo DEFAULT_ROLES[1]; 
....

À partir de PHP 7, les tableaux constants peuvent être définis en utilisant definecomme ci-dessous:

define('DEFAULT_ROLES', [
    'test',
    'development',
    'team'
]);

et différents éléments sont accessibles de la même manière qu'auparavant.

Je sais que c'est une question un peu ancienne, mais voici ma solution:

<?php
class Constant {

    private $data = [];

    public function define($constant, $value) {
        if (!isset($this->data[$constant])) {
            $this->data[$constant] = $value;
        } else {
            trigger_error("Cannot redefine constant $constant", E_USER_WARNING);
        }
    }

    public function __get($constant) {
        if (isset($this->data[$constant])) {
            return $this->data[$constant];
        } else {
            trigger_error("Use of undefined constant $constant - assumed '$constant'", E_USER_NOTICE);
            return $constant;
        }
    }

    public function __set($constant,$value) {
        $this->define($constant, $value);
    }

}
$const = new Constant;

Je l'ai défini car j'avais besoin de stocker des objets et des tableaux dans des constantes, j'ai donc installé également runkit sur php pour pouvoir rendre la variable $ const superglobale.

Vous pouvez l'utiliser comme $const->define("my_constant",array("my","values"));ou simplement$const->my_constant = array("my","values");

Pour obtenir la valeur, appelez simplement $const->my_constant;

PHP 7+

Depuis PHP 7, vous pouvez simplement utiliser la fonction define () pour définir un tableau constant:

define('ANIMALS', [
    'dog',
    'cat',
    'bird'
]);

echo ANIMALS[1]; // outputs "cat"

Peut même fonctionner avec des tableaux associatifs .. par exemple dans une classe.

class Test {

    const 
        CAN = [
            "can bark", "can meow", "can fly"
        ],
        ANIMALS = [
            self::CAN[0] => "dog",
            self::CAN[1] => "cat",
            self::CAN[2] => "bird"
        ];

    static function noParameter() {
        return self::ANIMALS[self::CAN[0]];
    }

    static function withParameter($which, $animal) {
        return "who {$which}? a {$animal}.";
    }

}

echo Test::noParameter() . "s " . Test::CAN[0] . ".<br>";
echo Test::withParameter(
    array_keys(Test::ANIMALS)[2], Test::ANIMALS["can fly"]
);

// dogs can bark.
// who can fly? a bird.

En utilisant la fonction exploser et imploser, nous pouvons improviser une solution:

$array = array('lastname', 'email', 'phone');
define('DEFAULT_ROLES', implode (',' , $array));
echo explode(',' ,DEFAULT_ROLES ) [1]; 

Cela fera écho email.

Si vous voulez l'optimiser davantage, vous pouvez définir 2 fonctions pour faire les choses répétitives pour vous comme ceci:

//function to define constant
function custom_define ($const , $array) {
    define($const, implode (',' , $array));
}

//function to access constant  
function return_by_index ($index,$const = DEFAULT_ROLES) {
            $explodedResult = explode(',' ,$const ) [$index];
    if (isset ($explodedResult))
        return explode(',' ,$const ) [$index] ;
}

J'espère que cela pourra aider . Codage heureux.

Faire une sorte de truc ser / deser ou encoder / décoder semble moche et vous oblige à vous souvenir de ce que vous avez fait exactement lorsque vous essayez d'utiliser la constante. Je pense que la variable statique privée de classe avec accesseur est une solution décente, mais je vous ferai mieux. Il suffit d'avoir une méthode getter statique publique qui renvoie la définition du tableau constant. Cela nécessite un minimum de code supplémentaire et la définition du tableau ne peut pas être accidentellement modifiée.

class UserRoles {
    public static function getDefaultRoles() {
        return array('guy', 'development team');
    }
}

initMyRoles( UserRoles::getDefaultRoles() );

Si vous voulez vraiment le faire ressembler à une constante définie, vous pouvez lui donner un nom tout en majuscules, mais il serait déroutant de se rappeler d'ajouter les parenthèses '()' après le nom.

class UserRoles {
    public static function DEFAULT_ROLES() { return array('guy', 'development team'); }
}

//but, then the extra () looks weird...
initMyRoles( UserRoles::DEFAULT_ROLES() );

Je suppose que vous pourriez rendre la méthode globale pour être plus proche de la fonctionnalité define () que vous demandiez, mais vous devriez vraiment cibler le nom constant de toute façon et éviter les globaux.

Vous pouvez définir comme ceci

define('GENERIC_DOMAIN',json_encode(array(
    'gmail.com','gmail.co.in','yahoo.com'
)));

$domains = json_decode(GENERIC_DOMAIN);
var_dump($domains);

Oui, vous pouvez définir un tableau comme constant. A partir de PHP 5.6 , il est possible de définir une constante comme expression scalaire, et il est également possible de définir une constante de tableau . Il est possible de définir des constantes en tant que ressource, mais cela doit être évité, car cela peut entraîner des résultats inattendus.

<?php
    // Works as of PHP 5.3.0
    const CONSTANT = 'Hello World';
    echo CONSTANT;

    // Works as of PHP 5.6.0
    const ANOTHER_CONST = CONSTANT.'; Goodbye World';
    echo ANOTHER_CONST;

    const ANIMALS = array('dog', 'cat', 'bird');
    echo ANIMALS[1]; // outputs "cat"

    // Works as of PHP 7
    define('ANIMALS', array(
        'dog',
        'cat',
        'bird'
    ));
    echo ANIMALS[1]; // outputs "cat"
?>

Avec la référence de ce lien

Ayez un codage heureux.

Si vous recherchez cela depuis 2009 et que vous n'aimez pas AbstractSingletonFactoryGenerators, voici quelques autres options.

N'oubliez pas que les tableaux sont "copiés" lorsqu'ils sont attribués ou, dans ce cas, retournés, vous obtenez donc pratiquement le même tableau à chaque fois. (Voir le comportement de copie sur écriture des tableaux en PHP.)

function FRUITS_ARRAY(){
  return array('chicken', 'mushroom', 'dirt');
}

function FRUITS_ARRAY(){
  static $array = array('chicken', 'mushroom', 'dirt');
  return $array;
}

function WHAT_ANIMAL( $key ){
  static $array = (
    'Merrick' => 'Elephant',
    'Sprague' => 'Skeleton',
    'Shaun'   => 'Sheep',
  );
  return $array[ $key ];
}

function ANIMAL( $key = null ){
  static $array = (
    'Merrick' => 'Elephant',
    'Sprague' => 'Skeleton',
    'Shaun'   => 'Sheep',
  );
  return $key !== null ? $array[ $key ] : $array;
}

si vous utilisez PHP 7 et 7+, vous pouvez également utiliser la récupération comme ceci

define('TEAM', ['guy', 'development team']);
echo TEAM[0]; 
// output from system will be "guy"

Les constantes ne peuvent contenir que des valeurs scalaires, je vous suggère de stocker la sérialisation (ou la représentation codée JSON) du tableau.