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

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

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

# 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 7+

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

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

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

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

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

Со ссылкой на эту ссылку

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

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

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

Если вы смотрите на это с 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+, вы также можете использовать такую ​​же выборку

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

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