Constantes PHP que contienen matrices?

Esto falló:

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

Aparentemente, las constantes no pueden contener matrices. ¿Cuál es la mejor manera de evitar esto?

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

//...

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

Esto parece un esfuerzo innecesario.

NOTA: si bien esta es la respuesta aceptada, vale la pena señalar que en PHP 5.6+ puede tener matrices constantes; consulte la respuesta de Andrea Faulds a continuación .

También puede serializar su matriz y luego ponerla en la constante:

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

# use it
$my_fruits = unserialize (FRUITS);

Desde PHP 5.6, puede declarar una matriz constante con const:

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

La sintaxis corta también funciona, como era de esperar:

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

Si tiene PHP 7, finalmente puede usar define(), tal como lo había intentado por primera vez:

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

Puede almacenarlos como variables estáticas de una clase:

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 no le gusta la idea de que otros puedan cambiar la matriz, un getter podría ayudarlo:

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

EDITAR

Desde PHP5.4, incluso es posible acceder a valores de matriz sin la necesidad de variables intermedias, es decir, los siguientes trabajos:

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

Si está utilizando PHP 5.6 o superior, use la respuesta de Andrea Faulds

Lo estoy usando así. Espero que ayude a otros.

config.php

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

En el archivo, donde necesito constantes.

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

Esto es lo que yo uso. Es similar al ejemplo proporcionado por soulmerge, pero de esta manera puede obtener la matriz completa o solo un valor único en la 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;
    }
}

Úselo así:

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

Puede almacenarlo como una cadena JSON en una constante. Y desde el punto de vista de la aplicación, JSON puede ser útil en otros casos.

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

A partir de PHP 5.6, puede definir matrices constantes utilizando la constpalabra clave como a continuación

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

y se puede acceder a diferentes elementos de la siguiente manera:

echo DEFAULT_ROLES[1]; 
....

Comenzando con PHP 7, las matrices constantes se pueden definir de la definesiguiente manera:

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

y se puede acceder a diferentes elementos de la misma manera que antes.

Sé que es una pregunta un poco vieja, pero aquí está mi solución:

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

Lo definí porque necesitaba almacenar objetos y matrices en constantes, así que también instalé runkit en php para poder hacer que la variable $ const sea superglobal.

Puedes usarlo como $const->define("my_constant",array("my","values"));o solo$const->my_constant = array("my","values");

Para obtener el valor simplemente llame $const->my_constant;

PHP 7+

A partir de PHP 7, puede usar el define () para definir una matriz constante:

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

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

Incluso puede trabajar con matrices asociativas ... por ejemplo en una clase.

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 la función de explosión e implosión podemos improvisar una solución:

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

Esto hará eco email .

Si desea optimizarlo más, puede definir 2 funciones para hacer las cosas repetitivas por usted de esta manera:

//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 ayude . Feliz codificación

Hacer algún tipo de truco de ser / deser o codificar / decodificar parece feo y requiere que recuerdes exactamente lo que hiciste cuando intentas usar la constante. Creo que la variable estática privada de clase con acceso es una solución decente, pero te haré una mejor. Solo tenga un método público de obtención estático que devuelva la definición de la matriz constante. Esto requiere un mínimo de código adicional y la definición de la matriz no puede modificarse accidentalmente.

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

initMyRoles( UserRoles::getDefaultRoles() );

Si realmente quiere que parezca una constante definida, puede darle un nombre en mayúsculas, pero sería confuso recordar agregar los paréntesis '()' después del nombre.

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

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

Supongo que podría hacer que el método sea global para estar más cerca de la funcionalidad de define () que estaba solicitando, pero de todos modos debería determinar el nombre constante y evitar los globales.

Puedes definir así

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

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

Sí, puede definir una matriz como constante. Desde PHP 5.6 en adelante , es posible definir una constante como una expresión escalar, y también es posible definir una constante de matriz . Es posible definir constantes como un recurso, pero debe evitarse, ya que puede 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"
?>

Con la referencia de este enlace

Que tengan una feliz codificación.

Si está buscando esto desde 2009, y no le gusta AbstractSingletonFactoryGenerators, aquí hay algunas otras opciones.

Recuerde, las matrices se "copian" cuando se asignan, o en este caso, se devuelven, por lo que prácticamente obtiene la misma matriz cada vez. (Consulte el comportamiento de copia en escritura de las matrices 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 está usando PHP 7 y 7+, también puede usar fetch como este

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

Las constantes solo pueden contener valores escalares, le sugiero que almacene la serialización (o representación codificada en JSON) de la matriz.