Lors de la définition d'une variable en PHP, il n'est pas nécessaire de déclarer un type. Initialement, une valeur entière est attribuée à la variable $a, et elle peut être facilement modifiée par d'autres types ultérieurement. Alors, comment cette variable $a est-elle stockée dans le code source PHP ? En gardant cette question à l’esprit, jetons un coup d’œil au code source de PHP.
Le code source de PHP est écrit en C. Une structure zval est utilisée dans le code source PHP pour stocker les variables créées dans le code PHP. Reprenons la définition de la structure zval et analysons-la brièvement.
Il s'agit du référentiel officiel de PHP sur Github : github.com/php/php-src La branche utilisée dans cet article est PHP-7.4.29.
Structure zval
Retrouvez ce fichier dans le code source PHP : php-src/Zend/zend_types.h Vous pouvez voir que la structure zval est définie comme suit, avec le code source à gauche. Le code source utilise les types définis par PHP, zend_uchar, uint16_t, uint32_t, etc. Ces types seront convertis en char short int, etc. sous différentes plates-formes et compilateurs pour la plate-forme. Pour faciliter la compréhension, je l'ai traduit en un type commun et je l'ai affiché sur le côté droit du code source. Dans le même temps, la fonction macro ZEND_ENDIAN_LOHI_3() est également étendue.
typedef struct _zval_struct zval;
...
《源代码》 《翻译后》
-------------------------------------------------------------------------------------------
struct _zval_struct { | struct _zval_struct {
zend_value value; | zend_value value;
union { | union {
struct { | struct {
ZEND_ENDIAN_LOHI_3( | unsigned char type;
zend_uchar type, | unsigned char type_flags;
zend_uchar type_flags, | union {
union { | unsigned short extra;
uint16_t extra; | } u;
} u | } v;
) | unsigned int type_info;
} v; | } u1;
uint32_t type_info; | union {
} u1; | unsigned int next;
union { | unsigned int cache_slot;
uint32_t next; | unsigned int opline_num;
uint32_t cache_slot; | unsigned int lineno;
uint32_t opline_num; | unsigned int num_args;
uint32_t lineno; | unsigned int fe_pos;
uint32_t num_args; | unsigned int fe_iter_idx;
uint32_t fe_pos; | unsigned int access_flags;
uint32_t fe_iter_idx; | unsigned int property_guard;
uint32_t access_flags; | unsigned int constant_flags;
uint32_t property_guard; | unsigned int extra;
uint32_t constant_flags; | } u2;
uint32_t extra; | };
} u2; |
}; |Dans la structure zval, la valeur de la variable est stockée dans l'attribut value du type zend_value. Et utilisez u1.v.type pour enregistrer le type de cette valeur. Par exemple, IS_LONG correspond au type entier et IS_STRING correspond au type chaîne.
union zend_value
Le type zend_value est également défini dans php-src/Zend/zend_types.h C'est une union Ce qui suit est la définition de l'union zend_value, et le code source est à gauche. Également sur le côté droit, j'ai également fait une traduction simple, traduisant zend_long uint32_t en un type commun pour une visualisation facile.
《源代码》 《翻译后》
------------------------------------------------------------------------------------
typedef union _zend_value { | typedef union _zend_value {
zend_long lval; /* long value */ | long lval;
double dval; /* double value */ | double dval;
zend_refcounted *counted; | zend_refcounted *counted;
zend_string *str; | zend_string *str;
zend_array *arr; | zend_array *arr;
zend_object *obj; | zend_object *obj;
zend_resource *res; | zend_resource *res;
zend_reference *ref; | zend_reference *ref;
zend_ast_ref *ast; | zend_ast_ref *ast;
zval *zv; | zval *zv;
void *ptr; | void *ptr;
zend_class_entry *ce; | zend_class_entry *ce;
zend_function *func; | zend_function *func;
struct { | struct {
uint32_t w1; | unsigned int w1;
uint32_t w2; | unsigned int w2;
} ww; | } ww;
} zend_value; | } zend_value;Une caractéristique de l'union est que la mémoire qu'elle occupe est la longueur correspondant au plus grand type dans ses attributs. Parmi eux, zend_long est de type long. Vous pouvez voir que la longueur de lval de type long et dval de type double est toutes deux de 8 octets. Les autres types de pointeurs à l'intérieur font également 8 octets. Le dernier attribut de structure ww est composé de deux types int et la longueur combinée est également de 8 octets. La longueur de cette union est donc de 8 octets.
Dans le code PHP que nous écrivons, les valeurs des données entières et à virgule flottante seront stockées directement dans lval et dval. S'il s'agit d'une chaîne, d'un tableau ou d'un autre type, un espace sera alloué pour stocker les données, et son adresse sera stockée dans zend_value, qui est l'attribut zval.value, tel que : zval.value.zend_long = 9527, zval .value.zend_string = adresse de chaîne de caractères, zval.value.zend_array = adresse de tableau. Marquez ensuite sur zval.u1.v.type que ce zval.value est un entier, une virgule flottante, une chaîne ou un autre type.
La définition du type zval.u1.v.type se trouve également dans le fichier php-src/Zend/zend_types.h :
/* regular data types */ #define IS_UNDEF 0 #define IS_NULL 1 #define IS_FALSE 2 #define IS_TRUE 3 #define IS_LONG 4 #define IS_DOUBLE 5 #define IS_STRING 6 #define IS_ARRAY 7 #define IS_OBJECT 8 #define IS_RESOURCE 9 #define IS_REFERENCE 10 /* constant expressions */ #define IS_CONSTANT_AST 11 /* internal types */ #define IS_INDIRECT 13 #define IS_PTR 14 #define IS_ALIAS_PTR 15 #define _IS_ERROR 15 /* fake types used only for type hinting (Z_TYPE(zv) can not use them) */ #define _IS_BOOL 16 #define IS_CALLABLE 17 #define IS_ITERABLE 18 #define IS_VOID 19 #define _IS_NUMBER 20
Utilisation de la mémoire de la structure zval
Ensuite, analysons ce dont zval a besoin. mémoire occupée.
value : zend_value tapez 8 octets.
u1 :
u1.v.type : caractère non signé 1 octet, u1.v.type_flags : caractère non signé 1 octet, u1.v.u : Il n'y a qu'un seul court non signé dans l'union L'attribut supplémentaire est de 2 octets, donc la structure de u1.v est de 4 octets au total.
u1.type_info : entier non signé 4 octets.
Donc la longueur de l'union u1 est la longueur de l'attribut le plus long : 4 octets.
u2 : C'est aussi une union, qui contient des attributs de type int, donc la longueur est de 4 octets.
Donc la mémoire totale occupée par zval est de 8 + 4 + 4 = 16 octets.
C'est-à-dire que lorsque nous écrivons du code PHP, si nous créons une variable entière, elle occupera en fait 16 octets de mémoire pendant le fonctionnement, et la surcharge de mémoire est au moins deux fois supérieure à celle du langage C. Bien entendu, cette double surcharge apporte également la flexibilité de PHP dans la gestion des variables.
Apprentissage recommandé : "Tutoriel vidéo PHP"
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!
Comment ouvrir le fichier php
Comment supprimer les premiers éléments d'un tableau en php
Que faire si la désérialisation php échoue
Comment connecter PHP à la base de données mssql
Comment connecter PHP à la base de données mssql
Résumé des connaissances de base de Java
Comment télécharger du HTML
Comment résoudre les caractères tronqués en PHP
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
