PHP Constantes Contendo Arrays?
https://stackoverflow.com/questions/1290318
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Este falhou:
define('DEFAULT_ROLES', array('guy', 'development team'));
Aparentemente, constantes podem não segurar matrizes. Qual é a melhor maneira de contornar isso?
define('DEFAULT_ROLES', 'guy|development team');
//...
$default = explode('|', DEFAULT_ROLES);
Esta parece ser esforço desnecessário.
Solução
NOTA: enquanto esta é a resposta aceita, é interessante notar que em PHP 5.6+ você pode ter matrizes const - ver resposta Andrea Faulds' abaixo .
Você também pode serializar a matriz e, em seguida, colocá-lo na constante:
# define constant, serialize array
define ("FRUITS", serialize (array ("apple", "cherry", "banana")));
# use it
$my_fruits = unserialize (FRUITS);
Outras dicas
Desde o PHP 5.6, você pode declarar uma constante matriz com const:
<?php
const DEFAULT_ROLES = array('guy', 'development team');
A sintaxe curta funciona também, como você esperaria:
<?php
const DEFAULT_ROLES = ['guy', 'development team'];
Se você tem PHP 7, você pode finalmente usar define(), assim como você tinha tentado em primeiro lugar:
<?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 idéia de que a matriz pode ser alterado por outros, uma ajuda getter poder:
class Constants {
private static $array = array('guy', 'development team');
public static function getArray() {
return self::$array;
}
}
$constantArray = Constants::getArray();
Editar
Desde PHP5.4, é possível até mesmo valores da matriz de acesso sem a necessidade de variáveis ??intermediárias, isto é, os seguintes trabalhos:
$x = Constants::getArray()['index'];
Se você estiver usando PHP 5.6 ou superior, o uso Andrea Faulds resposta
Eu estou usando-o como esta. Espero, ele vai ajudar os outros.
config.php
class app{
private static $options = array(
'app_id' => 'hello',
);
public static function config($key){
return self::$options[$key];
}
}
No arquivo, onde eu preciso constantes.
require('config.php');
print_r(app::config('app_id'));
Isto é o que eu uso. É semelhante ao exemplo fornecido pelo soulmerge, mas desta forma você pode obter o conjunto completo ou apenas um único valor 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 string JSON em uma constante. Eo ponto de vista da aplicaçã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 palavra-chave const como abaixo
const DEFAULT_ROLES = ['test', 'development', 'team'];
e elementos diferentes podem ser acessados ??como abaixo:
echo DEFAULT_ROLES[1];
....
Começando com o PHP 7, matrizes constantes podem ser definidos usando define como abaixo:
define('DEFAULT_ROLES', [
'test',
'development',
'team'
]);
e elementos diferentes podem ser acessados ??mesma forma que antes.
Eu sei que é uma pergunta pouco velho, mas aqui é 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;
I definido porque eu precisava para armazenar objetos e arrays em constantes para que eu também instalou runkit para php para que eu pudesse fazer 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 simplesmente chamar $const->my_constant;
Usando explodir e função implode podemos improvisar uma solução:
$array = array('lastname', 'email', 'phone');
define('DEFAULT_ROLES', implode (',' , $array));
echo explode(',' ,DEFAULT_ROLES ) [1];
Esta ecoará email.
Se você quer que 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.
fazendo algum tipo de ser / deser ou codificação / decodificação truque parece feio e exige que você se lembrar exatamente o que você fez quando você está tentando usar a constante. Eu acho que a variável estática privada classe com acessor é uma solução decente, mas eu vou fazer melhor. Basta ter um método getter público estático que retorna a definição da matriz constante. Isso requer um mínimo de código extra ea definição de matriz não pode ser acidentalmente modificado.
class UserRoles {
public static function getDefaultRoles() {
return array('guy', 'development team');
}
}
initMyRoles( UserRoles::getDefaultRoles() );
Se você quiser realmente fazer com que pareça uma constante definida que você poderia dar-lhe um nome de todas as tampas, mas então seria confuso para lembrar de adicionar o '()' 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() );
Eu suponho que você poderia tornar o método global para estar mais perto da funcionalidade define () que você estava pedindo, mas você realmente deve escopo o nome constante de qualquer forma e evitar globals.
Você pode definir como este
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 do PHP 7, você pode simplesmente usar o define () função para definir uma matriz constante:
define('ANIMALS', [
'dog',
'cat',
'bird'
]);
echo ANIMALS[1]; // outputs "cat"
pode até trabalhar com associativa matrizes .. 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.
Sim, você pode definir uma matriz tão constante. A partir de
<?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 do este link
Tenha um feliz codificação.
Se você estiver procurando isso a partir de 2009, e você não gosta AbstractSingletonFactoryGenerators, aqui estão algumas outras opções.
Lembre-se, as matrizes são "copiadas" quando atribuído, ou neste caso, voltou, então você está praticamente recebendo a mesma matriz de cada vez. (Veja comportamento copy-on-write 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;
}
Constantes só podem conter valores escalares, eu sugiro que você armazenar a serialização (ou JSON codificado representação) da matriz.
Eu concordo com eyze, constantes tendem a ser valor valores individuais necessários para toda a vida de sua aplicação. Você pode pensar sobre o uso de um arquivo de configuração em vez de constantes para esse tipo de coisa.
Se você realmente precisa de matrizes constantes, você poderia usar convenções de nomenclatura para matrizes pouco imitar:., Por exemplo, DB_Name, DB_USER, DB_HOST, etc
Isso está correto, você não pode usar matrizes para uma constante, única scaler e nulo. A idéia de usar um array para constantes parecer um pouco para trás para mim.
O que eu sugiro fazer em vez disso é definir sua própria classe constante e usar isso para obter a constante.
Você também pode explodir a matriz em uma série de constantes. (Uma solução muito velha escola) Afinal, a matriz é constante , então a única razão pela qual você precisa para isso, é global, rápido, pesquisa de certas teclas.
Assim, este:
define('DEFAULT_ROLES', array('guy', 'development team'));
se transformaria em:
define('DEFAULT_ROLES_0', 'guy');
define('DEFAULT_ROLES_1', 'development team');
Sim, há a poluição do namespace (e um monte de prefixo para evitar que ele) para ter em conta.
