PHP 常量包含数组？

Question

这失败了：

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

显然，常量不能保存数组。解决这个问题的最佳方法是什么？

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

//...

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

这似乎是不必要的努力。

Answer 1

注意：虽然这是公认的答案，但值得注意的是，在PHP 5.6+，你可以有常量数组 - 见安德烈福尔兹答案下面。

您也可以序列化您的数组，然后把它放到常数：

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

# use it
$my_fruits = unserialize (FRUITS);

Answer 2

自PHP 5.6，可以声明与const数组常量：

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

在短语法工作过，如你所期望的：

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

如果您有PHP 7，你终于可以使用define()，就像你曾经第一次尝试：

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

Answer 3

可以存储它们的一类为静态变量：

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

如果你不喜欢该阵列可以被别人改变想法，一个getter可以帮助：

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

修改

由于PHP5.4，甚至有可能而不需要中间变量，即以下工作访问数组值：

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

Answer 4

  

<强> 如果使用PHP 5.6或以上，使用安德烈福尔兹答案

我使用像这样。我希望，这将帮助别人。

<强>的config.php

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

在文件，其中我需要的常数。

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

Answer 5

这是我使用。它类似于由soulmerge提供的例子，但这样一来就可以得到阵列中的全阵列或只是一个单一的值。

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

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

使用这样的：

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

Answer 6

可以将其存储为一个常数的JSON字符串。和应用角度，JSON可以在其他情况下是有用的。

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

Answer 7

用PHP 5.6开始，可以使用const关键词中包含

限定恒定阵列

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

和不同的元件可以被访问，如下：

echo DEFAULT_ROLES[1]; 
....

用PHP 7开始，恒定阵列可使用如下面define来定义：

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

和不同的元件可如之前被访问相同的方式。

Answer 8

我知道这是一个有点老问题，但这里是我的解决方案：

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

我定义它，因为我需要存储在常量对象和数组所以我安装也runkit到PHP，所以我可以使$常量变量超全局。

可以使用它作为$const->define("my_constant",array("my","values"));或只是$const->my_constant = array("my","values");

要获取值只是简单地调用$const->my_constant;

Answer 9

使用爆炸和内爆功能，我们可以凑合的溶液：

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

此将回声email。

如果你想让它更优化它，你可以定义2个功能做重复的事情你是这样的：

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

希望有所帮助。快乐的编码。

Answer 10

做某种SER / DESER或编码的/解码的技巧也看起来丑陋，需要你准确地记住你做了什么，当你试图使用常量。我觉得跟访问类的私有静态变量是一个体面的解决办法，但我会做你一个人好。只要有一个返回常量数组定义一个公共静态getter方法。这需要一个最小的额外的代码和阵列定义不能被意外修改。

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

initMyRoles( UserRoles::getDefaultRoles() );

如果你想真正使它看起来像一个定义的常量，你可以给它一个全部大写的名字，但那么这将是混乱记得要加“（）”括号中的名字后。

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

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

我想你可以使该方法全球更接近你问的定义（）功能，但你真的应该范围不断名无论如何，避免全局变量。

Answer 11

可以这样定义

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

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

Answer 12

PHP 7+

从 PHP 7 开始，您可以只使用 定义（） 定义常量数组的函数：

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

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

Answer 13

可与关联数组的一类即使工作..例如

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 14

是，可以定义一个数组为常数。从的 PHP 5.6起下，也可以定义一个常数作为标量表达，并且还<强>可以定义一个数组常数即可。有可能定义常量作为资源，但应避免，因为这会导致不可预料的结果。

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

使用此链接的参考

有一个愉快的编码。

Answer 15

如果您是从2009年看这一点，你不喜欢AbstractSingletonFactoryGenerators，这里有一些其他的选择。

记住，阵列被“复制”时分配，或在这种情况下，返回，所以你每次几乎得到相同的阵列。 （参见在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;
}

Answer 16

常量只能包含标量值，建议你存储序列化（或JSON编码表示）的阵列组成。

Answer 17

我同意eyze，常量往往需要为应用程序的整个生命单个值的值。你可能会考虑使用一个配置文件，而不是常量这样的事情。

如果你真的需要不断的数组，你可以使用命名约定在一定程度上模拟阵列：例如DB_NAME，DB_USER，DB_HOST等

Answer 18

这是正确的，则无法使用阵列对于恒定的，仅定标器和空。使用常量的数组的想法似乎有点向后给我。

我的建议做的，而不是为自己定义常量类，并用它来获得恒定的。

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

Answer 20

您也可能会爆炸阵列成一系列常数。 （一个很老的学校溶液）毕竟，数组的恒的，所以你需要它，是全球，速度快，查找某些键的唯一原因。

因此，该：

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

会变成：

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

是的，有污染的命名空间（和大量的前缀，以防止它的），以考虑到。