Lassen Sie uns über die grundlegenden Variablen von PHP7 sprechen

Grundlegende Variablen von PHP7

Grundstruktur von Variablen

Wir alle wissen, dass PHP-Variablen schwach typisiert sind und es nicht erforderlich ist, den Typ bei der Deklaration anzugeben. Wie wird das umgesetzt? Dies muss mit der Grundstruktur von Variablen beginnen.

Zval-Implementierung

In der Quellcodedatei zend_type.h können Sie die Definition von zval sehen:

typedef struct _zval_struct     zval;

struct _zval_struct {
    zend_value        value;            /* value */
    union {
        struct {
            ZEND_ENDIAN_LOHI_4(
                zend_uchar    type,            /* active type */
                zend_uchar    type_flags,
                zend_uchar    const_flags,
                zend_uchar    reserved)        /* call info for EX(This) */
        } v;
        uint32_t type_info;
    } u1;
    union {
        uint32_t     next;                 /* hash collision chain */
        uint32_t     cache_slot;           /* literal cache slot */
        uint32_t     lineno;               /* line number (for ast nodes) */
        uint32_t     num_args;             /* arguments number for EX(This) */
        uint32_t     fe_pos;               /* foreach position */
        uint32_t     fe_iter_idx;          /* foreach iterator index */
        uint32_t     access_flags;         /* class constant access flags */
        uint32_t     property_guard;       /* single property guard */
        uint32_t     extra;                /* not further specified */
    } u2;
}

Die Struktur von zval besteht aus einer Union-Union zend_value, die den Wert oder Zeiger des Variablentyps speichert, und zwei Union-Unions u1 und u2 bestehen aus

• u1

u1 wird zum Speichern von Variablentypen und deren Informationen verwendet. Die darin enthaltenen Felder werden wie folgt verwendet:

Typ: Variablentypen aufzeichnen. Sie können über u2.v.type auf

type_flags zugreifen: die Flags, die den eindeutigen Variablentypen entsprechen (z. B. Konstantentypen, Referenzzähltypen, unveränderliche Typen).

const_flags: konstante Typflags

reserved: reservierte Felder

• u2

u2 ist hauptsächlich eine Hilfsfunktion der Struktur, deren Platz mit oder ohne u2 bereits belegt ist. , also nutzen Sie es. Das Hilfsfeld von u2 zeichnet viele Typinformationen auf, was für interne Funktionen von großem Nutzen ist, die Cache-Freundlichkeit verbessert oder Speicheradressierungsvorgänge reduziert. Einige dieser Bereiche werden hier vorgestellt.

next: Wird verwendet, um das Hash-Konfliktproblem zu lösen (der Hash-Konflikt wurde noch nicht verstanden) und die Position des nächsten Elements des Konflikts aufzuzeichnen.

cache_slot: Laufzeitcache. Beim Ausführen einer Funktion wird zunächst im Cache gesucht. Wenn sie nicht im Cache gefunden wird, wird anschließend in der globalen Funktionstabelle gesucht.

num_args: Die Anzahl der Parameter, die beim Aufruf der Funktion übergeben werden.

access_flags: Das Zugriffsflag der Objektklasse, z. B. public protected private.

• zend_value

typedef union _zend_value {
    zend_long         lval;                /* 整型*/
    double            dval;                /* 浮点型 */
    zend_refcounted  *counted;
    zend_string      *str;
    zend_array       *arr;
    zend_object      *obj;
    zend_resource    *res;
    zend_reference   *ref;
    zend_ast_ref     *ast;
    zval             *zv;
    void             *ptr;
    zend_class_entry *ce;
    zend_function    *func;
    struct {
        uint32_t w1;
        uint32_t w2;
    } ww;
} zend_value;

Wie aus zend__value ersichtlich ist, speichern Long- und Double-Typen Werte direkt, während andere Typen Zeiger sind und auf ihre jeweiligen Strukturen verweisen. Aufgrund der Struktur von zval müssen PHP-Variablen daher bei der Deklaration ihren Typ nicht explizit angeben, da sie Ihnen dabei helfen können, die entsprechende Speicherstruktur zu finden, unabhängig davon, welchen Werttyp Sie der Variablen zuweisen.

Nehmen Sie als Beispiel eine Variable, deren Wert eine Zeichenfolge ist. Ihre Struktur ist wie folgt:

Vergleich der zval-Strukturen von PHP5 und PHP7

• PHP5
• PHP7

Sie können sehen, dass der zval von PHP7 macht insgesamt nur 16 Bytes aus, im Vergleich zu den 48 Bytes, die von PHP5s zval belegt werden, spart es viel Speicher.

Darüber hinaus werden in PHP5 alle Variablen im Heap zugewiesen, für temporäre Variablen besteht jedoch keine Notwendigkeit, sie im Heap zuzuweisen. Daher wurde dies in PHP7 optimiert und temporäre Variablen werden direkt auf dem Stack angewendet.

Gemeinsame Variablentypen

Im Folgenden werden einige gängige Typen von Variablenstrukturen vorgestellt. Für weitere andere Typen können Sie den Quellcode selbst überprüfen.

Ganzzahlen und Gleitkommatypen

Bei Ganzzahlen und Gleitkommatypen werden Ganzzahlwerte aufgrund ihres geringen Platzbedarfs direkt in zval und in lval gespeichert, während Gleitkommawerte in dval gespeichert werden . .

typedef union _zend_value {
    zend_long         lval;             /* 整型*/
    double            dval;             /* 浮点型 */
    ... 
 }

Strings

Eine neue String-Struktur ist in PHP 7 definiert. Die Struktur ist wie folgt:

struct _zend_string {
    zend_refcounted_h ;
    zend_ulong        h;                /* hash value */
    size_t            len;
    char              val[1];
};

Die Bedeutung jedes Feldes oben:

gc: Variablenreferenzinformationen, alle Variablentypen, die Referenzzählung verwenden, haben diese Struktur.

h: Hash-Wert, der bei der Berechnung des Index im Array verwendet wird. (Es wird gesagt, dass dieser Vorgang die Leistung von PHP7 um 5% verbessert.

len: String-Länge, binäre Sicherheit wird durch diesen Wert gewährleistet.

val: String-Inhalt, Struktur mit variabler Länge, Speicher wird bei der Zuweisung entsprechend der Len-Länge zugewiesen
array

Array ist eine sehr leistungsfähige Datenstruktur in PHP. Die zugrunde liegende Implementierung ist eine gewöhnliche geordnete HashTable. Hier ist ein kurzer Blick auf ihre Struktur. Weitere Details folgen später.

typedef struct _zend_array HashTable;


struct _zend_array {
    zend_refcounted_h gc;
    union {
        struct {
            ZEND_ENDIAN_LOHI_4(
                zend_uchar    flags,
                zend_uchar    nApplyCount,
                zend_uchar    nIteratorsCount,
                zend_uchar    consistency)
        } v;
        uint32_t flags;
    } u;
    uint32_t          nTableMask;
    Bucket           *arData;
    uint32_t          nNumUsed;
    uint32_t          nNumOfElements;
    uint32_t          nTableSize;
    uint32_t          nInternalPointer;
    zend_long         nNextFreeElement;
    dtor_func_t       pDestructor;
}

Objekte

Die Objektstruktur von PHP7 wurde ebenfalls neu gestaltet, was sich stark von der Implementierung von PHP5 unterscheidet.

struct _zend_object {
    zend_refcounted_h gc;
    uint32_t          handle;
    zend_class_entry *ce; 
    const zend_object_handlers *handlers;
    HashTable        *properties; 
    zval              properties_table[1];
};

Hier sind einige der Felder:

gc: gc-Header

*ce: Klasse, die dem Objekt entspricht

*properties: HashTable-Struktur, Schlüssel ist der Eigenschaftsname des Objekts, Wert ist der Eigenschaftswert im Properties_tables-Array Der Offset in. Finden Sie den entsprechenden Eigenschaftswert in Properties_talbe über den Offset.

properties_talbe[1]: Speichert den Attributwert des Objekts

---

OK, schreiben wir das zuerst hier.

Das obige ist der detaillierte Inhalt vonLassen Sie uns über die grundlegenden Variablen von PHP7 sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!