PHP Constantes contenant des tableaux?

Question

a échoué:

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

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

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

//...

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

Cela semble tout effort inutile.

Answer 1

REMARQUE: tout cela est la réponse acceptée, il est intéressant de noter que PHP 5.6+ vous pouvez avoir des tableaux const - voir Andrea Faulds réponse ci-dessous .

Vous pouvez également sérialiser votre tableau et puis le mettre dans la constante:

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

# use it
$my_fruits = unserialize (FRUITS);

Answer 2

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 aussi, comme on pouvait s'y attendre:

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

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

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

Answer 3

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 ne voulez pas l'idée que le tableau peut être modifié par d'autres, un getter pourrait aider:

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

EDIT

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

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

Answer 4

  

Si vous utilisez PHP 5.6 ou ci-dessus, utilisez Andrea Faulds réponse

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

config.php

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

Dans le fichier, où j'ai besoin des constantes.

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

Answer 5

est ce que je l'utilise. Il est similaire à l'exemple fourni par soulmerge, mais cette façon vous pouvez obtenir la gamme complète 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 comme ceci:

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

Answer 6

Vous pouvez enregistrer comme une chaîne JSON dans une constante. Et 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);

Answer 7

A partir de PHP 5.6, vous pouvez définir des tableaux constants en utilisant le mot de const comme ci-dessous

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

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

echo DEFAULT_ROLES[1]; 
....

A partir de PHP 7, les matrices constantes peuvent être définies en utilisant define comme ci-dessous:

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

et différents éléments sont accessibles comme auparavant.

Answer 8

Je sais qu'il est un peu vieille question, 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 définissais parce que je avais besoin de stocker des objets et des tableaux dans des constantes, donc j'INSTALLÉ aussi runkit à php ainsi je pourrais faire la superglobale variable const $.

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

Pour obtenir la valeur tout simplement appeler $const->my_constant;

Answer 9

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

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

Cela écho email.

Si vous voulez optimiser plus 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] ;
}

L'espoir qui aide. codage heureux.

Answer 10

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

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

initMyRoles( UserRoles::getDefaultRoles() );

Si vous voulez vraiment faire ressembler à un nom constant que vous pourriez lui donner un tout bouchons défini, mais il serait alors confus de se rappeler d'ajouter le « () » entre 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 faire la méthode globale pour se rapprocher de la définir () la fonctionnalité que vous demandez, mais vous devriez vraiment la portée de toute façon le nom constant et éviter GLOBALS.

Answer 11

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);

Answer 12

PHP 7 +

PHP 7, vous pouvez utiliser simplement définie () fonction pour définir une matrice constante:

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

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

Answer 13

Peut même travailler avec des tableaux .. par exemple Associatif 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.

Answer 14

Oui, vous pouvez définir un tableau comme constante. De PHP 5.6 partir , il est possible de définir une constante comme une expression scalaire, et il est également possible de définir une constante tableau . Il est possible de définir des constantes comme une ressource, mais il doit être évité, car il peut provoquer 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

Avoir un codage heureux.

Answer 15

Si vous cherchez ce à partir de 2009, et ne vous plaît pas AbstractSingletonFactoryGenerators, voici quelques autres options.

Rappelez-vous, les tableaux sont « copiés » lorsqu'ils sont affectés, ou dans ce cas, de retour, de sorte que vous obtenez pratiquement le même tableau à chaque fois. (Voir le comportement de copie en écriture de 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;
}

Answer 16

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

Answer 17

Je suis d'accord avec eyze, les constantes ont tendance à être des valeurs de valeur unique nécessaires à la vie de votre application. Vous pourriez penser à l'aide d'un fichier de configuration au lieu des constantes pour ce genre de chose.

Si vous avez vraiment besoin des tableaux constants, vous pouvez utiliser les conventions de nommage à des tableaux un peu mimer:. Par exemple db_name, DB_USER, DB_HOST, etc

Answer 18

C'est exact, vous ne pouvez pas utiliser des tableaux pour une constante, que scaler et nulle. L'idée d'utiliser un tableau pour les constantes semblent un peu en arrière pour moi.

Ce que je propose de faire à la place est de définir votre propre classe constante et l'utiliser pour obtenir la constante.

Answer 19

define('MY_ARRAY_CONSTANT_DELIMETER', '|');       
define('MY_ARRAY',implode(MY_ARRAY_CONSTANT_DELIMETER,array(1,2,3,4)));

//retrieving the array
$my_array = explode(MY_ARRAY_CONSTANT_DELIMETER, MY_ARRAY);

Answer 20

Vous pouvez également faire exploser le tableau dans une série de constantes. (Une jolie ancienne solution de l'école) Après tout, le tableau est constante , de sorte que la seule raison pour laquelle vous avez besoin pour, est global, rapide, recherche de certaines touches.

Par conséquent ceci:

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

se transformerait en:

define('DEFAULT_ROLES_0', 'guy');
define('DEFAULT_ROLES_1', 'development team');

Oui, il y a la pollution de l'espace de noms (et beaucoup de préfixer pour l'empêcher) de prendre en compte.