Parlons des variables de base de PHP7

Variables de base de PHP7

Structure de base des variables

Nous savons tous que les variables PHP sont faiblement typées et qu'il n'est pas nécessaire de spécifier le type lors de leur déclaration. Alors, comment cela est-il mis en œuvre ? Cela doit commencer par la structure de base des variables.

Implémentation de Zval

Dans le fichier de code source zend_type.h, vous pouvez voir la définition de zval :

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

La structure de zval se compose d'une union union zend_value qui enregistre la valeur ou le pointeur du type de variable et de deux unions. u1 et u2 se composent de

• u1

u1 est utilisé pour enregistrer les types de variables et leurs informations. Les champs à l'intérieur sont utilisés comme suit :

type : enregistrer les types de variables. Vous pouvez accéder à

type_flags via u2.v.type : les indicateurs correspondant aux types uniques de variables (tels que les types constants, les types de comptage de références, les types immuables ont des indicateurs différents).

const_flags : drapeaux de type constant

reserved : champs réservés

• u2

u2 est principalement une fonction auxiliaire En raison de l'alignement mémoire de la structure, l'espace de u2 avec ou sans u2 a déjà occupé l'espace. , alors profitez-en. Le champ auxiliaire de u2 enregistre de nombreuses informations de type, ce qui est très bénéfique pour les fonctions internes, ou améliore la convivialité du cache ou réduit les opérations d'adressage mémoire. Certains de ces domaines sont présentés ici.

next : utilisé pour résoudre le problème du conflit de hachage (le conflit de hachage n'est pas encore compris) et enregistrer la position de l'élément suivant du conflit.

cache_slot : cache d'exécution. Lors de l'exécution d'une fonction, elle recherchera d'abord dans le cache. Si elle n'est pas trouvée dans le cache, elle recherchera ensuite dans la table des fonctions globales.

num_args : Le nombre de paramètres transmis lorsque la fonction est appelée

access_flags : L'indicateur d'accès de la classe d'objet, tel que 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;

Comme le montre zend__value, les types long et double stockent directement les valeurs, tandis que les autres types sont des pointeurs, pointant vers leurs structures respectives. Par conséquent, en raison de la structure de zval, les variables PHP n'ont pas besoin de spécifier explicitement leur type lors de leur déclaration, car quel que soit le type de valeur que vous attribuez à la variable, cela peut vous aider à trouver la structure de stockage correspondante.

Prenons comme exemple une variable dont la valeur est une chaîne. Sa structure est la suivante :

Comparaison des structures zval de PHP5 et PHP7

• PHP5
• PHP7

Vous pouvez voir que le zval de php7. ne représente que 16 octets au total, contre 48 octets occupés par zval de PHP5, cela économise beaucoup de mémoire.

De plus, en PHP5, toutes les variables sont allouées dans le tas, mais pour les variables temporaires, il n'est pas nécessaire d'allouer dans le tas. Par conséquent, cela a été optimisé en PHP7 et les variables temporaires sont appliquées directement sur la pile.

Types de variables courants

Ce qui suit présente plusieurs types courants de structures de variables. Pour d'autres types, vous pouvez consulter le code source vous-même.

Types entiers et à virgule flottante

Pour les types entiers et à virgule flottante, en raison de leur petit espace, les valeurs entières sont directement stockées dans zval et sont stockées dans lval, tandis que les valeurs à virgule flottante sont stockées dans dval .

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

Strings

Une nouvelle structure de chaînes est définie dans PHP 7. La structure est la suivante :

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

La signification de chaque champ ci-dessus :

gc : Informations de référence variable, tous les types de variables qui utilisent le comptage de références auront cette structure.

h : valeur de hachage, utilisée lors du calcul de l'index dans un tableau. (On dit que cette opération améliore les performances de PHP7 de 5%)

len : longueur de chaîne, la sécurité binaire est assurée grâce à cette valeur

val : contenu de chaîne, structure de longueur variable, demande de mémoire en fonction de la longueur len lors de l'allocation
Array

Array est une structure de données très puissante en PHP. Son implémentation sous-jacente est une HashTable ordonnée ordinaire. Voici un bref aperçu de sa structure. Plus de détails seront donnés plus tard.

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

Objects

La structure des objets de PHP7 a également été repensée, ce qui est très différent de l'implémentation de PHP5.

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

Voici quelques champs :

gc : en-tête gc

*ce : classe correspondant à l'objet

*properties : structure HashTable, key est le nom de la propriété de l'objet, value est la valeur de la propriété dans le Properties_tables tableau Le décalage dans , recherchez la valeur de propriété correspondante dans Properties_talbe via le décalage.

properties_talbe[1] : stocke la valeur d'attribut de l'objet

---

ok, écrivons ceci ici d'abord.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!