PHP Costanti contenenti le matrici?

Question

Questa non è riuscita:

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

A quanto pare, le costanti non possono tenere gli array. Qual è il modo migliore per aggirare questo?

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

//...

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

Questo mi sembra uno sforzo inutile.

Answer 1

Nota: mentre questa è la risposta accettata, vale la pena notare che in PHP 5.6+ è possibile avere array const - vedere risposta Andrea Faulds' sotto .

È anche possibile serializzare l'array e poi metterlo in costante:

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

# use it
$my_fruits = unserialize (FRUITS);

Answer 2

A partire da PHP 5.6, è possibile dichiarare una costante di matrice con const:

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

La breve sintassi funziona anche, come ci si aspetterebbe:

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

Se avete PHP 7, si può finalmente utilizzare define(), proprio come avevi prima provato:

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

Answer 3

È possibile memorizzare le 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 può essere modificato da altri, un getter potrebbe aiutare:

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

Modifica

Dal PHP5.4, è anche possibile accedere ai valori di matrice senza la necessità di variabili intermedie, cioè i seguenti lavori:

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

Answer 4

  

Se si sta utilizzando PHP 5.6 o superiore, utilizzare Andrea Faulds risposta

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

Answer 5

Questo è quello che uso. È simile all'esempio fornito da soulmerge, ma in questo modo è possibile ottenere la gamma completa o solo un singolo valore nella matrice.

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

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

Si usa in questo modo:

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

Answer 6

È possibile memorizzare come una stringa JSON in una costante. E punto di vista applicativo, JSON può essere utile in altri casi.

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

Answer 7

A partire da PHP 5.6, è possibile definire le matrici costanti utilizzando parole chiave come const seguente

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

e diversi elementi si può accedere come di seguito:

echo DEFAULT_ROLES[1]; 
....

A partire dal PHP 7, matrici costanti possono essere definiti utilizzando define come sotto:

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

e diversi elementi sono accessibili come prima.

Answer 8

Lo so che è un po 'vecchia questione, ma qui è 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;

ho definita perché avevo bisogno di memorizzare gli oggetti e gli array di costanti così ho installato anche runkit a PHP così ho potuto fare il superglobale variabile $ const.

Si può usare come $const->define("my_constant",array("my","values")); o semplicemente $const->my_constant = array("my","values");

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

Answer 9

Utilizzando esplodere e la funzione implodiamo siamo in grado di improvvisare una soluzione:

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

In questo modo eco email.

Se si vuole ottimizzare più è possibile definire 2 funzioni di fare le cose ripetitive per voi 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] ;
}

La speranza che aiuta. codifica Felice.

Answer 10

Facendo una sorta di ser / desertificazione o di codifica / decodifica trucco sembra brutto e si richiede di ricordare che cosa esattamente hai fatto quando si sta tentando di utilizzare la costante. Credo che la variabile statica privata classe con funzione di accesso è una soluzione decente, ma farò voi uno migliore. Basta avere un metodo getter public static che restituisce la definizione della costante di matrice. Ciò richiede un minimo di codice aggiuntivo e la definizione del campo non può essere modificato accidentalmente.

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

initMyRoles( UserRoles::getDefaultRoles() );

Se si vuole fare davvero sembrare una costante definita si potrebbe dare un tutto nome di tappi, ma poi sarebbe fonte di confusione per ricordare di aggiungere la '()' 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() );

Immagino che si potrebbe rendere il metodo globale per essere più vicini alla funzionalità define () che stavi chiedendo, ma si dovrebbe davvero ambito il nome della costante in ogni caso ed evitare globali.

Answer 11

È possibile definire come questo

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

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

Answer 12

PHP + 7

A partire da PHP 7, si può semplicemente utilizzare il define () funzione per definire una matrice costante:

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

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

Answer 13

Può anche lavorare con array associativi .. per 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.

Answer 14

Sì, è possibile definire un array come costante. Da PHP 5.6 in poi , è possibile definire una costante come un'espressione scalare, ed è anche possibile definire una costante di matrice . E '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

Avere una codifica felice.

Answer 15

Se cercate questo a partire dal 2009, e non ti piace AbstractSingletonFactoryGenerators, qui sono alcune altre opzioni.

Ricordate, gli array vengono "copiati" quando viene assegnato, o in questo caso, è tornato, quindi si è praticamente sempre lo stesso array ogni volta. (Vedere comportamento copy-on-write di 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;
}

Answer 16

Le costanti possono contenere solo valori scalari, ti suggerisco di memorizzare la serializzazione (o JSON codificato rappresentazione) della matrice.

Answer 17

Sono d'accordo con eyze, costanti tendono ad essere i valori dei singoli valori necessari per tutta la durata della vostra applicazione. Si potrebbe pensare di utilizzare un file di configurazione, invece di costanti per questo genere di cose.

Se si ha realmente bisogno le matrici costanti, è possibile utilizzare le convenzioni di denominazione per gli array in qualche modo imitare:. Per esempio DB_NAME, DB_USER, DB_HOST, etc

Answer 18

Questo è corretto, non è possibile utilizzare le matrici per una costante, solo scaler e nullo. L'idea di utilizzare una matrice per le costanti sembrano un po 'indietro per me.

Quello che suggerisco di fare, invece è definire la propria classe costante e l'uso che per ottenere la costante.

Answer 19

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

Answer 20

Si potrebbe anche esplodere la matrice in una serie di costanti. (Una bella vecchia soluzione di scuola) Dopo tutto, la matrice è costante , quindi l'unico motivo è necessario per, è globale, veloce, ricerca di alcuni tasti.

Quindi questo:

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

si trasformerebbe in:

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

Sì, c'è l'inquinamento dello spazio dei nomi (e un sacco di prefisso per impedirlo) di prendere in considerazione.