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

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

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

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

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

//...

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

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

+383
источник поделиться
21 ответ

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

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

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

# use it
$my_fruits = unserialize (FRUITS);
+487
источник

С 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'));
+777
источник

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

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'];
+140
источник

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

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

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

define ("FRUITS", json_encode(array ("apple", "cherry", "banana")));    
$fruits = json_decode (FRUITS);    
var_dump($fruits);
+9
источник

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

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

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

echo DEFAULT_ROLES[1]; 
....

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

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

и к другим элементам можно обращаться так же, как и раньше.

+6
источник

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

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

+3
источник

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

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

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

+2
источник

Выполнение какого-либо трюка ser/deser или encode/decode кажется уродливым и требует, чтобы вы помнили, что именно вы делали, когда пытаетесь использовать константу. Я думаю, что приватная статическая переменная класса с accessor - это достойное решение, но я сделаю вам еще лучше. Просто используйте открытый метод 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() );

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

+2
источник

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

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

$domains = json_decode(GENERIC_DOMAIN);
var_dump($domains);
+2
источник

PHP 7 +

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

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

echo ANIMALS[1]; // outputs "cat"
+2
источник

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

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.
+2
источник

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

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

Иметь счастливое кодирование.

+1
источник

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

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

0
источник

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

define('TEAM', ['guy', 'development team']);
echo TEAM[0]; 
// output from system will be "guy"
0
источник

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

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

-1
источник

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

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

-2
источник
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);
-2
источник

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

Отсюда следует:

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

Повернулся бы:

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

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

-2
источник

Посмотрите другие вопросы по меткам или Задайте вопрос