PHP константы, содержащие массивы?

Это не удалось:

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

Видимо, константы не могут содержать массивы. Каков наилучший способ обойти это?

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

//...

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

Это кажется ненужным усилием.

ПРИМЕЧАНИЕ: хотя это и является принятым ответом, стоит отметить, что в PHP 5.6+ у вас могут быть массивы const - см. Ответ Андреа Фолдса ниже .

Вы также можете сериализовать свой массив и затем поместить его в константу:

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

# use it
$my_fruits = unserialize (FRUITS);

Начиная с 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'));

Вы можете хранить их как статические переменные класса:

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

Если вам не нравится идея, что массив может быть изменен другими, может помочь геттер:

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

Если вы используете 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'));

Это то, что я использую. Это похоже на пример, предоставленный 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'

Вы можете сохранить его в виде строки JSON в константе. И с точки зрения приложения, JSON может быть полезен в других случаях.

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

Начиная с PHP 5.6, вы можете определять постоянные массивы, используя constключевое слово, как показано ниже

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

и различные элементы могут быть доступны, как показано ниже:

echo DEFAULT_ROLES[1]; 
....

Начиная с PHP 7, постоянные массивы могут быть определены, defineкак показано ниже:

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

и различные элементы могут быть доступны так же, как и раньше.

Я знаю, что это старый вопрос, но вот мое решение:

<?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 суперглобальной.

Вы можете использовать его как $const->define("my_constant",array("my","values"));или просто$const->my_constant = array("my","values");

Чтобы получить значение просто позвоните $const->my_constant;

PHP 7+

Начиная с PHP 7, вы можете просто использовать функцию define () для определения константного массива:

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

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

Может даже работать с ассоциативными массивами .. например, в классе.

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.

Используя функцию взрыва и взрыва, мы можем импровизировать решение:

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

Надеюсь, это поможет . Удачного кодирования.

Делать какие-то трюки с сер / дезер или кодировать / декодировать кажется уродливым и требовать, чтобы вы помнили, что именно вы сделали, когда пытаетесь использовать константу. Я думаю, что закрытая статическая переменная класса с аксессором - неплохое решение, но я сделаю вам лучше. Просто используйте публичный статический метод получения, который возвращает определение константного массива. Это требует минимум дополнительного кода и определение массива не может быть случайно изменено.

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

Я полагаю, вы могли бы сделать метод глобальным, чтобы он был ближе к функциональности define (), о которой вы просили, но вы все равно должны ограничить имя константы и избегать глобальных переменных.

Вы можете определить как это

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

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

Да, Вы можете определить массив как константу. Начиная с 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"
?>

С ссылкой по этой ссылке

Удачного кодирования.

Если вы смотрите это с 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;
}

если вы используете PHP 7 и 7+, вы также можете использовать fetch

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

Константы могут содержать только скалярные значения, я предлагаю вам сохранить сериализацию (или JSON-кодированное представление) массива.