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

https://stackoverflow.com/questions/1290318

18-09-2019
|

Вопрос

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

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

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

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

//...

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

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

Решение

ПРИМЕЧАНИЕ:хотя это принятый ответ, стоит отметить, что в 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
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;

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

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

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

Выполнение какого-либо трюка ser/deser или encode/decode кажется уродливым и требует от вас помнить, что именно вы делали, когда пытались использовать константу.Я думаю, что частная статическая переменная класса с аксессором — достойное решение, но я сделаю вам еще одно решение.Просто используйте общедоступный статический метод получения, который возвращает определение константного массива.Для этого требуется минимум дополнительного кода, и определение массива не может быть случайно изменено.

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

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

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.

Да, вы можете определить массив как константу.От 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;
}

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

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

Если вам действительно нужны константные массивы, вы можете использовать соглашения об именах, чтобы немного имитировать массивы:например DB_Name, DB_USER, DB_HOST и т. д.

Это правильно, вы не можете использовать массивы для констант, только масштабатор и ноль.Идея использования массива для констант кажется мне немного устаревшей.

Вместо этого я предлагаю определить собственный класс констант и использовать его для получения константы.

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

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

Отсюда это:

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

Превратится в:

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

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow