Constantes PHP contendo matrizes?

Isso falhou:

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

Aparentemente, as constantes não podem conter matrizes. Qual é a melhor maneira de contornar isso?

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

//...

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

Isso parece um esforço desnecessário.

NOTA: enquanto esta é a resposta aceita, vale a pena notar que no PHP 5.6+ você pode ter arrays const - veja a resposta de Andrea Faulds abaixo .

Você também pode serializar sua matriz e depois colocá-la na constante:

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

# use it
$my_fruits = unserialize (FRUITS);

Desde o PHP 5.6, você pode declarar uma matriz constante com const:

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

A sintaxe curta também funciona, como seria de esperar:

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

Se você possui o PHP 7, pode finalmente usar define(), exatamente como havia tentado:

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

Você pode armazená-los como variáveis ​​estáticas de uma 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';

Se você não gosta da ideia de que a matriz pode ser alterada por outras pessoas, um getter pode ajudar:

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

EDITAR

Desde o PHP5.4, é possível acessar valores de array sem a necessidade de variáveis ​​intermediárias, ou seja, o seguinte funciona:

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

Se você estiver usando o PHP 5.6 ou superior, use a resposta de Andrea Faulds

Eu estou usando assim. Espero que ajude os outros.

config.php

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

Em arquivo, onde eu preciso de constantes.

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

É isso que eu uso. É semelhante ao exemplo fornecido pelo soulmerge, mas dessa forma você pode obter a matriz completa ou apenas um valor único na matriz.

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

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

Use-o assim:

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

Você pode armazená-lo como uma sequência JSON em uma constante. E do ponto de vista da aplicação, o JSON pode ser útil em outros casos.

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

A partir do PHP 5.6, você pode definir matrizes constantes usando constpalavras-chave como abaixo

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

e diferentes elementos podem ser acessados ​​como abaixo:

echo DEFAULT_ROLES[1]; 
....

A partir do PHP 7, matrizes constantes podem ser definidas usando-se definecomo abaixo:

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

e diferentes elementos podem ser acessados ​​da mesma maneira que antes.

Eu sei que é uma pergunta um pouco antiga, mas aqui está a minha solução:

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

Eu o defini porque precisava armazenar objetos e matrizes em constantes, então instalei também o runkit no php para poder tornar a variável $ const superglobal.

Você pode usá-lo como $const->define("my_constant",array("my","values"));ou apenas$const->my_constant = array("my","values");

Para obter o valor, basta chamar $const->my_constant;

PHP 7+

No PHP 7, você pode simplesmente usar a função define () para definir uma matriz constante:

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

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

Pode até trabalhar com matrizes associativas. Por exemplo, em uma 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.

Usando a função explodir e implodir, podemos improvisar uma solução:

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

Isso ecoará email.

Se você deseja otimizá-lo mais, você pode definir 2 funções para fazer as coisas repetitivas para você assim:

//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] ;
}

Espero que ajude . Feliz codificação.

Fazer algum tipo de truque de ser / deser ou codificar / decodificar parece feio e exige que você se lembre exatamente do que fez quando está tentando usar a constante. Eu acho que a variável estática privada de classe com o acessador é uma solução decente, mas farei uma melhor. Basta ter um método público getter estático que retorne a definição da matriz constante. Isso requer um mínimo de código extra e a definição da matriz não pode ser modificada acidentalmente.

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

initMyRoles( UserRoles::getDefaultRoles() );

Se você realmente quer fazer com que pareça uma constante definida, pode dar um nome com maiúsculas, mas seria confuso lembrar de adicionar os parênteses '()' após o nome.

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

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

Suponho que você possa tornar o método global mais próximo da funcionalidade define () que estava solicitando, mas realmente deve definir o nome da constante de qualquer maneira e evitar globais.

Você pode definir assim

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

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

Sim, você pode definir uma matriz como constante. A partir do PHP 5.6 , é possível definir uma constante como uma expressão escalar, e também é possível definir uma constante da matriz . É possível definir constantes como um recurso, mas deve ser evitado, pois pode causar resultados inesperados.

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

Com a referência deste link

Tenha uma codificação feliz.

Se você está procurando isso em 2009 e não gosta de AbstractSingletonFactoryGenerators, aqui estão algumas outras opções.

Lembre-se de que as matrizes são "copiadas" quando atribuídas ou, nesse caso, retornadas, portanto, você praticamente obtém a mesma matriz sempre. (Veja o comportamento de cópia na gravação de matrizes em 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;
}

se você estiver usando PHP 7 e 7+, também pode usar a busca assim

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

As constantes podem conter apenas valores escalares. Sugiro que você armazene a serialização (ou representação codificada em JSON) da matriz.