Constantes PHP que contienen matrices?

StackOverflow https://stackoverflow.com/questions/1290318

  •  18-09-2019
  •  | 
  •  

Pregunta

Esto fracasó: 

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

Al parecer, las constantes no pueden sostener matrices. ¿Cuál es la mejor manera de evitar esto? 

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

//...

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

Esto parece como un esfuerzo innecesario.

¿Fue útil?

Solución

Nota: si bien esto es la respuesta aceptada, vale la pena señalar que en PHP 5.6+ puede tener matrices const - ver Andrea respuesta Faulds' a continuación.

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

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

# use it
$my_fruits = unserialize (FRUITS);

Otros consejos

A partir de PHP 5.6, se puede declarar una constante de matriz con const: 

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

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

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

Si tiene PHP 7, que finalmente puede utilizar define(), tal como se había intentado en primer lugar: 

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

Se pueden almacenar 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 te gusta la idea de que la matriz se puede cambiar por otros, un captador podría ayudar: 

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 la matriz sin la necesidad de variables intermedias, es decir, las siguientes obras: 

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

Si está usando PHP 5.6 o superior, utilice respuesta Andrea Faulds

lo estoy usando como este. Espero, que ayudará a los demás.

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 se puede obtener el conjunto completo o sólo un único valor 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;
    }
}

Utilice esta manera: 

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

Se pueden almacenar como una cadena JSON en una constante. Y el punto de vista de 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, se pueden definir matrices constantes usando la palabra clave, como a continuación const 

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

y diferentes elementos se puede acceder como a continuación: 

echo DEFAULT_ROLES[1]; 
....

A partir de PHP 7, las matrices constantes se pueden definir utilizando define como a continuación: 

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

y diferentes elementos se puede acceder misma manera que antes.

Sé que es una cuestión de edad poco, 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;

he definido porque necesitaba para almacenar objetos y las matrices de constantes por lo que también se instala runkit a php por lo que podría hacer que la variable $ const superglobal.

Se puede utilizar como $const->define("my_constant",array("my","values")); o simplemente $const->my_constant = array("my","values");

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

Uso de la función de explotar y implosionan 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 usted quiere que optimizarlo más se puede definir 2 funciones para hacer las cosas repetitivas para que 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 de codificación.

Haciendo una especie de ser / deser o codificar / decodificar truco parece feo y se requiere para recordar qué es exactamente lo que hizo cuando usted está tratando de utilizar la constante. Creo que la variable estática privada clase con una solución de acceso es decente, pero haré algo mejor. Sólo echar un método getter estática pública que devuelve la definición de la matriz constante. Esto requiere un mínimo de código extra y la definición de la matriz no se puede modificar de forma accidental. 

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

initMyRoles( UserRoles::getDefaultRoles() );

Si usted quiere realmente hacer que se vea como una constante definida que podría darle un nombre de todas las tapas, pero entonces sería confuso para recordar a añadir el '()' 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 global para estar más cerca de la funcionalidad definir () le pedías, pero que realmente debe alcance el nombre de constante de todos modos y evito globales.

Se puede definir como esto 

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

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

PHP 7 +

A partir de PHP 7, puede usar simplemente define () función para definir una matriz constante: 

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

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

incluso se 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.

Sí, se puede definir una matriz como constante. De 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

Tener una codificación feliz.

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

Recuerde, las matrices se "copian" cuando se asigna, o en este caso, devueltos, por lo que están recibiendo prácticamente la misma matriz cada vez. (Véase el comportamiento de copia por escritura de 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;
}

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

Estoy de acuerdo con eyze, constantes tienden a ser valor valores individuales necesarios para toda la vida de su aplicación. Se podría pensar acerca del uso de un archivo de configuración en lugar de constantes para este tipo de cosas.

Si realmente necesita matrices constantes, se puede usar convenciones de nombres a las matrices algo mímico:. DB_NAME por ejemplo, DB_USER, DB_HOST, etc.

Eso es correcto, no se puede utilizar matrices para una constante, sólo el escalador y nula. La idea de utilizar una serie de constantes parecer un poco hacia atrás para mí.

Lo que sugiero hacer en su lugar es definir su propia clase constante y la use para obtener la constante. 

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

También es posible explotar la matriz en una serie de constantes. (Una solución escuela bastante viejo) Después de todo, la matriz es constante , por lo que la única razón por la que lo necesite para, es global, rápido, las operaciones de búsqueda de ciertas teclas.

Por lo tanto esto: 

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

se convertiría en: 

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

Sí, no hay contaminación del espacio de nombres (y un montón de prefijar para evitarlo) para tener en cuenta.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top