expresiones - php class

¿Constantes de PHP que contienen matrices?

Question

Esto falló:

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

Al parecer, 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.

Answer 1

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 archivo, donde necesito constantes.

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

Answer 2

PHP 7+

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

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

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

Answer 3

A partir de PHP 5.6, puede definir matrices constantes usando la palabra clave const 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]; 
....

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

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

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

Answer 4

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

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

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

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

Si tiene PHP 7, finalmente puede usar define() , tal como lo intentó primero:

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

Answer 5

Eso es correcto, no puede utilizar matrices para una constante, solo escalador y nulo. La idea de usar una matriz para constantes me parece un poco al revés.

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

Answer 6

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 solo 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;
    }
}

Úsalo así:

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

Answer 7

Estoy de acuerdo con Eyze, las constantes tienden a ser valores únicos necesarios para toda la vida de su aplicación. Podría pensar en usar un archivo de configuración en lugar de constantes para este tipo de cosas.

Si realmente necesita matrices constantes, puede usar convenciones de nomenclatura para imitar de alguna manera las matrices: por ejemplo, DB_Name, DB_USER, DB_HOST, etc.

Answer 8

Hacer algún tipo de truco ser / deser o codificar / decodificar parece feo y requiere que recuerdes lo que hiciste exactamente cuando intentas usar la constante. Creo que la variable estática privada de clase con accessor es una solución decente, pero te haré una mejor. Simplemente tenga un método getter estático público 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 se puede modificar accidentalmente.

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

initMyRoles( UserRoles::getDefaultRoles() );

Si realmente quieres que se vea como una constante definida, puedes darle el nombre de 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 define () que estaba solicitando, pero de todos modos debería definir el nombre de la constante y evitar los elementos globales.

Answer 9

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.

Answer 10

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

Answer 11

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

Answer 12

Puedes almacenarlas 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 puede ser cambiada 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 matriz sin la necesidad de variables intermedias, es decir, los siguientes trabajos:

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

Answer 13

Puedes definir así

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

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

Answer 14

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 to php para poder hacer que la variable $ const fuera superglobal.

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

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

Answer 15

Sí, puedes 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.

Tener una codificación feliz.

Answer 16

También puede explotar la matriz en una serie de constantes. (una solución bastante antigua) Después de todo, la matriz es constante , por lo que la única razón por la que la necesita es la búsqueda global y rápida de ciertas claves.

De ahí esto:

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

Se convertiría en:

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

Sí, hay que tener en cuenta la contaminación del espacio de nombres (y muchos prefijos para evitarla).

Answer 17

Usando la función explotar e implosionar podemos improvisar una solución:

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

Esto se hará eco de email .

Si desea que lo optimice más, puede definir 2 funciones para hacer las cosas repetitivas 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 codificacion

Answer 18

NOTA: si bien esta es la respuesta aceptada, vale la pena señalar que en PHP 5.6+ puede tener matrices const - vea 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);

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