web-dev-qa-db-fra.com

PHP Des constantes contenant des tableaux?

Cela a échoué:

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

Apparemment, les constantes ne peuvent pas contenir de tableaux. Quel est le meilleur moyen de contourner cela?

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

//...

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

Cela semble être un effort inutile.

phparraysconstantsscalar
367
Nick Heiner

NOTE: Bien que ce soit la réponse acceptée, il convient de noter que dans PHP 5.6+, vous pouvez avoir des tableaux const - voir la réponse d’Andrea Faulds ci-dessous .

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

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

# use it
$my_fruits = unserialize (FRUITS);
480
user156676

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 vous le souhaitiez:

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

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

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

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 peut vous aider:

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

MODIFIER

Depuis PHP 5.4, il est même possible d’accéder aux valeurs d’un tableau sans avoir besoin de variables intermédiaires, c’est-à-dire que les travaux suivants fonctionnent:

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

Si vous utilisez PHP 5.6 ou une version ultérieure, utilisez Andrea Faulds answer

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 fichier, où j'ai besoin de constantes.

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

C'est ce que j'utilise. Il est similaire à l'exemple fourni par soulmerge, mais vous pouvez ainsi obtenir le tableau complet ou juste une valeur unique 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'
12
Syclone

Vous pouvez le stocker en tant que 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);
9
Mahesh Talpade

À partir de PHP 5.6, vous pouvez définir des tableaux de constantes en utilisant le mot clé const 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 de constantes peuvent être définis en utilisant define comme ci-dessous: 

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

et différents éléments peuvent être accédés de la même manière qu'auparavant. 

5
Altaf Hussain

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 parce que j'avais besoin de stocker des objets et des tableaux dans des constantes. J'ai donc également installé runkit to php pour pouvoir créer la variable $ const superglobal.

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

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

3
Rikudou_Sennin

En utilisant les fonctions 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 . Bonne codage.

2
MD. Sahib Bin Mahboob

Peut même travailler 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.
2
Thielicious

Vous pouvez définir comme ça

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

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

Effectuer une sorte d'astuce ser/deser ou encoder/décoder semble laid et nécessite que vous vous souveniez 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 vais vous faire mieux. Ayez simplement une méthode getter 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 modifiée accidentellement.

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

initMyRoles( UserRoles::getDefaultRoles() );

Si vous voulez vraiment faire en sorte qu’elle ressemble à une constante définie, vous pouvez lui donner un nom en majuscule, mais il serait alors déroutant de ne pas oublier 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() );

J'imagine que vous pourriez rendre la méthode globale plus proche de la fonctionnalité define () que vous demandiez, mais vous devez de toute façon définir le nom de la constante de façon à éviter les globales.

2
Daniel Skarbek

PHP 7+

A partir de 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"
2
Rabin Lama Dong

Oui, vous pouvez définir un tableau comme constant. À partir de PHP 5.6 et ultérieur}, il est possible de définir une constante en tant qu'expression scalaire. 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

Avoir un codage heureux.

1
Sahil Patel

Si vous regardez ceci à partir de 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, renvoyés, vous obtenez donc pratiquement le même tableau à chaque fois. (Voir 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;
}
1
biziclop

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

0
Alix Axel