Stałe PHP zawierające Tablice?

Od wersji PHP 5.6 Można zadeklarować stałą tablicy za pomocą const:

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

Krótka składnia również działa, jak można się spodziewać:

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

Jeśli masz PHP 7, możesz w końcu użyć define(), tak jak wcześniej próbowałeś:

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

Można je zapisać jako zmienne statyczne klasy:

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

Jeśli nie podoba Ci się pomysł, że tablica może być zmieniana przez innych, getter może pomóc:

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

EDIT

Od PHP5. 4 możliwy jest nawet dostęp do wartości tablic bez potrzeby stosowania zmiennych pośrednich, tzn. następujące działania:

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

Jeśli używasz PHP 5.6 lub nowszego, użyj

Config.php

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

W pliku, gdzie potrzebuję stałych.

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

Tego właśnie używam. Jest to podobne do przykładu dostarczonego przez soulmerge, ale w ten sposób można uzyskać pełną tablicę lub tylko jedną wartość w tablicy.

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

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

Użyj go tak:

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

Możesz zapisać go jako ciąg JSON w stałej. I punkt widzenia aplikacji, JSON może być przydatny w innych przypadkach.

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

Począwszy od PHP 5.6, możesz zdefiniować tablice stałe za pomocą słowa kluczowego const Jak poniżej

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

I różne elementy można uzyskać jak poniżej:

echo DEFAULT_ROLES[1]; 
....

Począwszy od PHP 7, stałe tablice mogą być zdefiniowane za pomocą define Jak poniżej:

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

I różne elementy mogą być dostępne w ten sam sposób, jak wcześniej.

PHP 7 +

Począwszy od PHP 7, możesz po prostu użyć funkcji define() do zdefiniowania stałej tablicy:

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

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

Wiem, że to trochę stare pytanie, ale oto moje rozwiązanie:

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

Zdefiniowałem go, ponieważ musiałem przechowywać obiekty i tablice w stałych, więc zainstalowałem również runkit do php, więc mogłem zrobić zmienną $const superglobal.

Możesz go używać jako $const->define("my_constant",array("my","values")); lub po prostu $const->my_constant = array("my","values");

Aby uzyskać wartość po prostu zadzwoń $const->my_constant;

Tak, możesz zdefiniować tablicę jako stałą. Począwszy od PHP 5.6 , możliwe jest zdefiniowanie stałej jako wyrażenia skalarnego, a także możliwe jest zdefiniowanie stałej tablicy. Możliwe jest definiowanie stałych jako zasobu, ale należy tego unikać, ponieważ może to spowodować nieoczekiwane wyniki.

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

Z odniesieniem ten link

Może pracować nawet z tablicami Asocjacyjnymi.. na przykład w klasie.

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.

Używając funkcji explode i implode możemy zaimprowizować rozwiązanie:

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

To będzie echo email.

Jeśli chcesz, aby zoptymalizować go bardziej można zdefiniować 2 funkcje, aby zrobić powtarzalne rzeczy dla Ciebie jak to:

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

Wykonywanie jakiejś sztuczki ser/deser lub kodowanie / dekodowanie wydaje się brzydkie i wymaga zapamiętania, co dokładnie zrobiłeś, gdy próbujesz użyć stałej. Myślę, że Klasa prywatna statyczna zmienna z accessor jest przyzwoitym rozwiązaniem, ale zrobię coś lepszego. Wystarczy mieć publiczną statyczną metodę getter, która zwraca definicję tablicy stałych. Wymaga to minimum dodatkowego kodu i definicja tablicy nie może zostać przypadkowo zmodyfikowana.

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

initMyRoles( UserRoles::getDefaultRoles() );

Jeśli chcesz naprawdę aby wyglądało to jak zdefiniowana stała, możesz nadać jej nazwę All caps, ale wtedy byłoby mylące pamiętać o dodaniu nawiasów '()' po nazwie.

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

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

Przypuszczam, że możesz sprawić, że metoda global będzie bliższa funkcjonalności define (), o którą prosiłeś, ale tak czy inaczej powinieneś rozszerzyć nazwę stałej i unikać globali.

Możesz zdefiniować tak

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

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

Jeśli szukasz tego z 2009 roku, a nie lubisz AbstractSingletonFactoryGenerators, oto kilka innych opcji.

Pamiętaj, że tablice są "kopiowane" po przypisaniu, lub w tym przypadku zwracane, więc praktycznie otrzymujesz tę samą tablicę za każdym razem. (Zobacz zachowanie tablic przy zapisie (copy-on-write) w 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;
}

Jeśli używasz PHP 7 & 7+, Możesz również użyć fetch w ten sposób

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

Stałe mogą zawierać tylko wartości skalarne, sugeruję przechowywanie serializacji (lub reprezentacji zakodowanej JSON) tablicy.