PHP-Konstanten mit Arrays?

Dies schlug fehl:

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

Anscheinend können Konstanten keine Arrays enthalten. Was ist der beste Weg, um dies zu umgehen?

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

//...

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

Dies scheint unnötiger Aufwand zu sein.

HINWEIS: Obwohl dies die akzeptierte Antwort ist, ist es erwähnenswert, dass Sie in PHP 5.6+ konstante Arrays haben können - siehe Andrea Faulds Antwort unten .

Sie können Ihr Array auch serialisieren und dann in die Konstante einfügen:

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

# use it
$my_fruits = unserialize (FRUITS);

Seit PHP 5.6 können Sie eine Array-Konstante deklarieren mit const:

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

Die kurze Syntax funktioniert auch wie erwartet:

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

Wenn Sie PHP 7 haben, können Sie es endlich verwenden define(), so wie Sie es zuerst versucht hatten:

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

Sie können sie als statische Variablen einer Klasse speichern:

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

Wenn Ihnen die Idee nicht gefällt, dass das Array von anderen geändert werden kann, kann ein Getter hilfreich sein:

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

BEARBEITEN

Seit PHP5.4 ist es sogar möglich, auf Array-Werte zuzugreifen, ohne dass Zwischenvariablen erforderlich sind, dh Folgendes funktioniert:

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

Wenn Sie PHP 5.6 oder höher verwenden, verwenden Sie Andrea Faulds Antwort

Ich benutze es so. Ich hoffe, es wird anderen helfen.

config.php

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

In Datei, wo ich Konstanten brauche.

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

Das benutze ich. Es ähnelt dem Beispiel von soulmerge, aber auf diese Weise können Sie das vollständige Array oder nur einen einzelnen Wert im Array erhalten.

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

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

Verwenden Sie es so:

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

Sie können es als JSON-Zeichenfolge in einer Konstante speichern. Aus Anwendungssicht kann JSON in anderen Fällen nützlich sein.

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

Ab PHP 5.6 können Sie konstante Arrays mit dem folgenden constSchlüsselwort definieren

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

Auf verschiedene Elemente kann wie folgt zugegriffen werden:

echo DEFAULT_ROLES[1]; 
....

Ab PHP 7 können konstante Arrays wie folgt definiert werden define:

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

Auf verschiedene Elemente kann wie zuvor zugegriffen werden.

Ich weiß, dass es eine etwas alte Frage ist, aber hier ist meine Lösung:

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

Ich habe es definiert, weil ich Objekte und Arrays in Konstanten speichern musste, also habe ich auch Runkit auf PHP installiert, damit ich die Variable $ const superglobal machen kann.

Sie können es als $const->define("my_constant",array("my","values"));oder nur verwenden$const->my_constant = array("my","values");

Um den Wert zu erhalten, rufen Sie einfach an $const->my_constant;

PHP 7+

Ab PHP 7 können Sie einfach die Funktion define () verwenden, um ein konstantes Array zu definieren:

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

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

Kann sogar mit assoziativen Arrays arbeiten .. zum Beispiel in einer Klasse.

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.

Mit der Explosions- und Implodierfunktion können wir eine Lösung improvisieren:

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

Dies wird widerhallen email.

Wenn Sie möchten, dass es weiter optimiert wird, können Sie zwei Funktionen definieren, um die sich wiederholenden Dinge für Sie wie folgt zu erledigen:

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

Ich hoffe, das hilft . Viel Spaß beim Codieren.

Es scheint hässlich, eine Art Ser / Deser- oder Codierungs- / Decodierungs-Trick auszuführen, und Sie müssen sich daran erinnern, was genau Sie getan haben, als Sie versucht haben, die Konstante zu verwenden. Ich denke, die private statische Variable der Klasse mit Accessor ist eine anständige Lösung, aber ich werde Ihnen eine bessere machen. Verwenden Sie einfach eine öffentliche statische Getter-Methode, die die Definition des konstanten Arrays zurückgibt. Dies erfordert ein Minimum an zusätzlichem Code und die Array-Definition kann nicht versehentlich geändert werden.

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

initMyRoles( UserRoles::getDefaultRoles() );

Wenn Sie es wirklich wie eine definierte Konstante aussehen lassen möchten, können Sie ihm einen Namen mit Großbuchstaben geben. Dann wäre es verwirrend, daran zu denken, die Klammern '()' nach dem Namen einzufügen.

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

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

Ich nehme an, Sie könnten die Methode global machen, um näher an der von Ihnen gewünschten define () -Funktionalität zu sein, aber Sie sollten den konstanten Namen trotzdem auf jeden Fall festlegen und globale Werte vermeiden.

Sie können so definieren

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

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

Ja, Sie können ein Array als konstant definieren. Ab PHP 5.6 ist es möglich, eine Konstante als skalaren Ausdruck zu definieren , und es ist auch möglich, eine Array-Konstante zu definieren . Es ist möglich, Konstanten als Ressource zu definieren, dies sollte jedoch vermieden werden, da dies zu unerwarteten Ergebnissen führen kann.

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

Mit dem Verweis auf diesen Link

Viel Spaß beim Codieren.

Wenn Sie dies ab 2009 suchen und AbstractSingletonFactoryGenerators nicht mögen, finden Sie hier einige andere Optionen.

Denken Sie daran, dass Arrays bei der Zuweisung "kopiert" oder in diesem Fall zurückgegeben werden, sodass Sie praktisch jedes Mal das gleiche Array erhalten. (Siehe Copy-on-Write-Verhalten von Arrays 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;
}

Wenn Sie PHP 7 & 7+ verwenden, können Sie auch Fetch wie folgt verwenden

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

Konstanten können nur skalare Werte enthalten. Ich schlage vor, Sie speichern die Serialisierung (oder JSON-codierte Darstellung) des Arrays.