Costanti PHP contenenti array?

Questo non è riuscito:

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

Apparentemente, le costanti non possono contenere array. Qual è il modo migliore per aggirare questo?

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

//...

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

Questo sembra uno sforzo inutile.

NOTA: sebbene questa sia la risposta accettata, vale la pena notare che in PHP 5.6+ è possibile disporre di array cost - vedere la risposta di Andrea Faulds di seguito .

Puoi anche serializzare l'array e inserirlo nella costante:

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

# use it
$my_fruits = unserialize (FRUITS);

Da PHP 5.6, puoi dichiarare una costante di array con const:

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

La sintassi breve funziona anche, come ci si aspetterebbe:

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

Se hai PHP 7, puoi finalmente usare define(), proprio come hai provato per la prima volta:

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

Puoi memorizzarli come variabili statiche di una classe:

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

Se non ti piace l'idea che l'array possa essere modificato da altri, un getter potrebbe aiutarti:

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

MODIFICARE

A partire da PHP5.4, è persino possibile accedere ai valori dell'array senza la necessità di variabili intermedie, ovvero i seguenti lavori:

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

Se stai usando PHP 5.6 o versioni successive, usa la risposta di Andrea Faulds

Lo sto usando in questo modo. Spero che aiuterà gli altri.

config.php

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

Nel file, dove ho bisogno di costanti.

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

Questo è quello che uso. È simile all'esempio fornito da soulmerge, ma in questo modo è possibile ottenere l'array completo o solo un singolo valore nell'array.

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

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

Usalo in questo modo:

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

È possibile memorizzarlo come stringa JSON in una costante. E dal punto di vista dell'applicazione, JSON può essere utile in altri casi.

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

A partire da PHP 5.6, puoi definire array costanti usando la constparola chiave come di seguito

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

e diversi elementi sono accessibili come di seguito:

echo DEFAULT_ROLES[1]; 
....

A partire da PHP 7, le matrici costanti possono essere definite definecome di seguito:

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

e si può accedere a elementi diversi come prima.

So che è una domanda un po 'vecchia, ma ecco la mia soluzione:

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

L'ho definito perché avevo bisogno di memorizzare oggetti e matrici in costanti, quindi ho installato anche runkit su php in modo da rendere superglobal la variabile $ const.

Puoi usarlo come $const->define("my_constant",array("my","values"));o solo$const->my_constant = array("my","values");

Per ottenere il valore basta semplicemente chiamare $const->my_constant;

PHP 7+

A partire da PHP 7, puoi semplicemente usare la funzione define () per definire un array costante:

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

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

Può persino lavorare con array associativi .. ad esempio in una classe.

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.

Usando la funzione esplodere e implodere possiamo improvvisare una soluzione:

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

Questo echeggerà email.

Se vuoi che lo ottimizzi di più, puoi definire 2 funzioni per fare le cose ripetitive per te in questo modo:

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

Spero che aiuti . Buona codifica.

Fare una sorta di trucco ser / deser o di codifica / decodifica sembra brutto e richiede di ricordare cosa hai fatto esattamente quando stai cercando di usare la costante. Penso che la variabile statica privata di classe con accessor sia una soluzione decente, ma farò di meglio. Basta avere un metodo getter statico pubblico che restituisce la definizione dell'array costante. Ciò richiede un minimo di codice aggiuntivo e la definizione dell'array non può essere modificata accidentalmente.

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

initMyRoles( UserRoles::getDefaultRoles() );

Se vuoi davvero farlo sembrare una costante definita potresti dargli un nome tutto maiuscolo, ma sarebbe confuso ricordare di aggiungere le parentesi '()' dopo il nome.

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

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

Suppongo che tu possa rendere il metodo globale più vicino alla funzionalità define () che stavi chiedendo, ma dovresti comunque considerare il nome costante ed evitare i globali.

Puoi definire così

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

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

Sì, è possibile definire un array come costante. Da PHP 5.6 in poi , è possibile definire una costante come espressione scalare ed è anche possibile definire una costante di array . È possibile definire le costanti come una risorsa, ma dovrebbe essere evitato, in quanto può causare risultati imprevisti.

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

Con il riferimento di questo link

Buona codifica.

Se stai cercando questo dal 2009 e non ti piace AbstractSingletonFactoryGenerators, ecco alcune altre opzioni.

Ricorda, le matrici vengono "copiate" quando assegnate, o in questo caso, restituite, quindi praticamente ottieni sempre la stessa matrice. (Vedi comportamento copia su scrittura degli array in 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;
}

se stai usando PHP 7 e 7+, puoi usare anche fetch in questo modo

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

Le costanti possono contenere solo valori scalari, ti suggerisco di memorizzare la serializzazione (o la rappresentazione codificata JSON) dell'array.