Umgehung der nicht geparsten einfachen Syntax

Question

Ich möchte eine Klasseneigenschaft haben, die es ermöglicht, einen Ausdruck auf der rechten Seite des Gleichheitszeichens zu platzieren. Alle PHP-Versionen ersticken an dem folgenden Code, aber er ist so geschrieben, damit er in Zukunft leichter erweiterbar ist.

/* Example SDK Class */
class SDK
{
    /* Runtime Option Flags */
    // Strings
    #  0: Makes no change to the strings.
    var $STRING_NONE        = (1 << 0);
    #  1: Removes color codes from the string.
    var $STRING_STRIP_COLOR = (1 << 1);
    #  2: Removes language codes from the string.
    var $STRING_STRIP_LANG  = (1 << 2);
    #  3: Removes all formatting from the string.
    var $STRING_STRIP       = SELF::STRING_STRIP_COLOR & SELF::STRING_STRIP_LANG;
    #  4: Converts color codes to HTML & UTF-8.
    var $STRING_HTML        = (1 << 3);
    #  8: Converts color codes to ECMA-48 escape color codes & UTF-8.
    var $STRING_CONSOLE     = (1 << 4);
    # 16: Changes player names only.
    var $STRING_NAMES       = (1 << 5);
    # 32: Changes host names only.
    var $STRING_HOSTS       = (1 << 6);
    function SDK($fString = SELF::STRING_HTML & SELF::STRING_NAMES & SELF_HOST)
    {
        // constructor code.
    }
}

$SDK &= new SDK(SDK::STRING_NONE);

(1 << 0) scheint mir eine sehr einfache Syntax zu sein, und es ist nicht nachvollziehbar, warum PHP so etwas nicht zulassen würde. Fällt jemandem eine Lösung ein, die die Lesbarkeit und zukünftige Erweiterbarkeit des folgenden Codes beibehält?

Answer 1

Wenn Sie in PHP eine Klassenkonstante oder -eigenschaft deklarieren, können Sie nur einen primitiven Wert als Standardwert angeben. So funktioniert zum Beispiel diese Klassendeklaration nicht:

class TEST {
 const ABC = 2 * 4;
 const DEF = some_function();
 static $GHI = array(
   'key'=> 5 * 3,
 );
}

Aber diese Klassendeklaration wird es:

class TEST {
 const ABC = 8;
 static $GHI = 15;
}

Diese Regeln gelten für Standardwerte für Klassenkonstanten/-eigenschaften - können Sie immer andere Variablen mit den Ergebnissen eines Ausdrucks initialisieren:

$a= array(
 'a'=> 1 * 2,
 'b'=> 2 * 2,
 'c'=> 3 * 2,
);

Der Grund für dieses Verhalten bei der Klassendeklaration ist folgender: Ausdrücke sind wie Verben. Sie etwas tun . Klassen sind wie Substantive: Sie etwas bekannt machen . Eine deklarative Anweisung sollte niemals die Nebeneffekte einer Aktionsanweisung hervorrufen. Die Forderung nach primitiven Standardwerten setzt diese Regel durch.

Vor diesem Hintergrund können wir die ursprüngliche Klasse wie folgt umstrukturieren:

class SDK
{

    static protected $_types= null;

    static public function getType($type_name) {
        self::_init_types();
        if (array_key_exists($type_name, self::$_types)) {
            return self::$_types[$type_name];
        } else {
            throw new Exception("unknown type $type_name");
        }
    }

    static protected function _init_types() {
        if (!is_array(self::$_types)) {
            self::$_types= array(
                'STRING_NONE'=> 1 << 0,
                // ... rest of the "constants" here
                'STRING_HOSTS'=> 1 << 6
            );
        }
    }

    function __construct($fString = null) {
        if (is_null($fString)) {
            $fString= self::getType('STRING_NONE') & self::getType('STRING_HOSTS');
        }
        var_dump($fString);
    }

}

$SDK &= new SDK(SDK::getType('STRING_HOSTS'));

Answer 2

PHP-Klassen-Eigenschaft kann no einen Ausdruck in seiner Deklaration haben.

[...] Diese Deklaration kann eine Initialisierung enthalten, aber diese Initialisierung muss ein konstanter Wert sein, d.h. sie muss zur Kompilierzeit ausgewertet werden können und darf nicht von Laufzeitinformationen abhängen, um ausgewertet zu werden . [...]

Quelle: PHP-Handbuch: Eigenschaften

Der folgende Code würde gut funktionieren, da die Informationen zur Kompilierzeit ermittelt werden können und der Compiler nirgendwo anders nachsehen muss, ob mathematische oder String-Funktionen die Informationen erhalten.

class goodExample
{
    // These are OK.
    var $Var = 1;
    const consts = 'I\'m a Constant Property of the class goodExample.';
    static $static = array(FALSE, TRUE);
}

Die folgende Angabe ist hingegen nicht gültig, da ihr Wert geparst werden muss, um ihren wahren Wert zu ermitteln. Dies ist in PHP überhaupt nicht zulässig. Die var $Var erfordert eine mathematische Operation. Die const consts erfordert Konkationen und einen variablen Look-up, um seinen Wert zu erhalten, so dass zwei Gründe, warum das nicht funktionieren würde. Zu guter Letzt, die static Eigenschaft $static erfordert zwei weitere mathematische Operationen, um den wahren Wert zu erhalten.

class badExample
{
    // These are NOT OK.
    var $Var = 1 + 1;
    const consts = "I'm a constant property of the class " . __CLASS__ . '.';
    static $static = array((1 << 0), (1 << 2));
}

Const s & Static Schlüsselwörter

Sobald Sie diese Eigenschaften deklarieren, wird ihr Wert kann nicht ändern.

const

[...] Konstanten unterscheiden sich von normalen Variablen dadurch, dass Sie verwenden das $-Symbol nicht zur Deklaration von oder sie verwenden.

Der Wert muss ein konstanter Ausdruck sein und nicht (zum Beispiel) eine Variable, eine Eigenschaft, ein Ergebnis einer mathematischen Operation oder ein Funktionsaufruf.

Es ist auch möglich für Schnittstellen Konstanten zu haben.

Quelle: PHP-Handbuch: Klassen-Konstanten

static

[...] Die Deklaration von Klasseneigenschaften oder -methoden als statisch macht sie zugänglich, ohne dass eine Instanziierung der Klasse erforderlich ist. Auf eine als statisch deklarierte Eigenschaft kann nicht mit einem instanziierten Klassenobjekt zugegriffen werden (eine statische Methode hingegen schon).

Quelle: PHP-Handbuch: Statisches Schlüsselwort

Static kann außerhalb der Klasse verwendet werden, solange Sie auf den Klassennamen verweisen.

Answer 3

Ich glaube, Ihr Problem liegt einfach an den vielen var s, die Sie da drin haben. Sie sollten wahrscheinlich alle ersetzt werden durch const . var war in PHP 4 für die Deklaration von Member-Variablen notwendig, verursacht aber in PHP 5 einen Fehler. Sie sollten const , public usw. stattdessen ab PHP 5.

Answer 4

PHP ist in der Lage (1 << 0) das Problem ist nur, weil Sie die var wenn Sie Folgendes verwenden sollten const . Außerdem wird self::VARIABLE ist für statische Variablen gedacht, und ich glaube, es sollte self::$variable (es sei denn, Sie definieren sie als const