namespace MyEnums;

class OrderStatus {
public static function Cart($val = false) {
return ($val) ? __(“In cart”) : __FUNCTION__;
}
public static function Partial($val = false) {
return ($val) ? __(“Partial payment”) : __FUNCTION__;
}
public static function Paid($val = false) {
return ($val) ? __(“Paid”) : __FUNCTION__;
}
}

Beispiel:
echo ‘key: ‘.\MyEnums\OrderStatus::Cart();
echo ‘value: ‘.\MyEnums\OrderStatus::Cart(true);

die Lösung von Manuel ist die einzige mit der ich vernünftig arbeiten kann.
Const-Varianten haben das Problem dass man sich drum kümmern muss, dass die z.B. bei Methodenparametern auch verwendet werden, um Lesbarkeit zu erhalten. Auch ob der Wertebereich richtig ist kommt erst zur Laufzeit raus.

Statt

foo(MyEnum::value1)
kann man eben auch

foo(1)

oder
foo(“falscher wert”)
schreiben, ohne dass eine schlaue IDE das als falsch anmeckern kann.

Bei der Java4-Variante kann man das mit Type Hinting verhindern.

in

foo(MyEnum $value)

kann ich richtigerweise nur ein MyEnum übergeben, dass ich mit einem der statischen Konstruktoren erzeugt habe.

Daumen hoch! Dass das aus Java 4 stammt wusste ich noch gar nicht…

Nachteilig ist das sich die “werte” nicht gegen ein interface binden können, weil statische methoden durch ein interface nicht deklarierbar sind.

Den Overhead beim Erzeugen des Objekts lasse ich mal außen vor.

Hach, native Enums wären halt schon was schönes in PHP, inklusive returntype-hinting und (was vermutlich niemals kommt) typehinting für native datentypen.

In Manuels Beispiel erzeugt der Methodenaufruf jedesmal ein neues Objekt und man könnte unterschiedliche Werte an verschiedenen Stellen verwenden. Meintest du das so?

Was aber immer bleibt, ist die Klassenabhängigkeit durch den statischen Aufruf.

final class MyEnum
{
private $value;
private function __construct($value)
{
$this->value = $value;
}

public static function value1()
{
return new self(__METHOD__);
}

public static function value2()
{
return new self(__METHOD__);
}

public function getValue()
{
return $value;
}
public function __toString()
{
return (string) $value;
}
}

die kann man dann sogar in einem switch case typsicher verwenden:

$value = MyEnum::value1();

switch($value)
{
case MyEnum::value1():
echo ‘Enum rocks’;
break;
case MyEnum::value2():
echo ‘Enum2 rocks!’;
break;
}

oder mit method typehints.

class MyClass
{
public function __construct(MyEnum $enum)
{

}
}

lg Manuel

Ps.: mit etwas mehraufwand kann man die dinger sogar iterierbar machen