La composition et les types de variables PHP

Cet article présente principalement la composition et les types de variables PHP. Les amis intéressés peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Composants de la variable PHP :

Nom de la variable : Le nom de la variable en langage PHP commence par $ + Anglais/trait de soulignement, et peut contenir des chiffres et traits de soulignement, lettres, sensibles à la casse. Dans le même temps, PHP prend également en charge les variables composées, sous la forme de $$A, ce qui augmente la dynamique de PHP.

Type : PHP est un langage faiblement typé et peut attribuer tout type de valeur.

Contenu : Il ne peut y avoir qu'une seule valeur à la fois.

Il existe 8 types de données dans le langage PHP, répartis en trois grandes catégories :

1. , string;

2. Types composites : objet, tableau

3. Types spéciaux : NULL, ressource

php, en tant que langage faiblement typé, implémente toutes les variables. stocker les données via la structure zval, qui contient non seulement la valeur de la variable, mais également le type de la variable, qui est au cœur du typage faible de PHP.

Structure de données zval :

struct _zval_struct{
  zvalue_value value;    //存储变量的值
  zend_unint  refcount_gc; //引用计数
  zend_char  is_ref_gc;  // 是否为引用
  zend_char  type;     //存储变量的类型
}

Parmi elles, zvalue_value n'est pas une structure afin d'économiser de la mémoire, elle est implémentée par union, car la variable ne peut représenter qu'un seul type à la fois. en même temps. Son prototype :

typedef union _zvalue_value{
  long lval;         
  double dval;
  struct {
      char *val;
      int len;      //字符串的长度
    }str;
  HashTable *ht;       //保存数组
  zend_object_value obj;   //对象
}zvalue_value;

Table de hachage :

De nombreuses implémentations au sein de PHP sont basées sur des tables de hachage : portée des variables, table de fonctions, attributs de classe, méthodes Etc., de nombreuses données à l'intérieur du moteur Zend sont stockées dans des tables de hachage.

Les tableaux PHP utilisent des tables de hachage pour stocker les données associées. L'implémentation de la table de hachage utilise deux structures de données, HashTable et Bucket :

HashTable :

typedef struct _hashtable { 
  uint nTableSize;    // hash Bucket的大小，最小为8，以2x增长。
  uint nTableMask;    // nTableSize-1 ， 索引取值的优化
  uint nNumOfElements;  // hash Bucket中当前存在的元素个数，count()函数会直接返回此值 
  ulong nNextFreeElement; // 下一个数字索引的位置
  Bucket *pInternalPointer;  // 当前遍历的指针（foreach比for快的原因之一）
  Bucket *pListHead;     // 存储数组头元素指针
  Bucket *pListTail;     // 存储数组尾元素指针
  Bucket **arBuckets;     // 存储hash数组
  dtor_func_t pDestructor;  // 在删除元素时执行的回调函数，用于资源的释放
  zend_bool persistent;    // 指出了Bucket内存分配的方式。如果persisient为TRUE，
                  则使用操作系统本身的内存分配函数为Bucket分配内存，否则使用
                  PHP的内存分配函数。
  unsigned char nApplyCount; // 标记当前hash Bucket被递归访问的次数（防止多次递归）
  zend_bool bApplyProtection;// 标记当前hash桶允许不允许多次访问，不允许时，最多只能递归3次
#if ZEND_DEBUG
  int inconsistent;
#endif
} HashTable;

L'expansion de capacité dans HashTable est toujours ajustée pour être proche de la puissance entière de 2 de la taille initiale. Parce que :

Lors de la sélection des emplacements, l'opération & est utilisée à la place de modulo. C'est parce que l'opération modulo est relativement plus coûteuse que l'opération ET au niveau du bit. La fonction du masque est de mapper la valeur de hachage à la plage d'index que l'emplacement peut stocker. Par exemple : la valeur d'index d'une certaine clé est 21, la taille de la table de hachage est 8, puis le masque est 7 et la représentation binaire de la somme est : 10101 & 111 = 101, soit 5 en décimal. Parce que le système binaire de 2 à la puissance d'un entier -1 est particulier : les valeurs des N bits suivants sont toutes à 1, ce qui facilite la cartographie des valeurs s'il s'agit d'un nombre ordinaire et combiné en binaire. , cela affectera le résultat de la valeur de hachage. Ensuite, la distribution moyenne des valeurs calculées par la fonction de hachage peut être affectée.

bucket :

typedef struct bucket {
  ulong h;      // 对char *key进行hash后的值，或者是用户指定的数字索引值
  uint nKeyLength;  // hash关键字的长度，如果数组索引为数字，此值为0
  void *pData;    // 指向value，一般是用户数据的副本，如果是指针数据，则指向pDataPtr
  void *pDataPtr;   //如果是指针数据，此值会指向真正的value，同时上面pData会指向此值
  struct bucket *pListNext;  // 整个hash表的下一元素
  struct bucket *pListLast;  // 整个哈希表该元素的上一个元素
  struct bucket *pNext;    // 存放在同一个hash Bucket内的下一个元素
  struct bucket *pLast;    // 同一个哈希bucket的上一个元素
// 保存当前值所对于的key字符串，这个字段只能定义在最后，实现变长结构体
  char arKey[1];       
} Bucket;

La valeur de hachage est stockée dans le compartiment au lieu de l'index de hachage.

Le dernier champ de la structure ci-dessus est utilisé pour enregistrer la chaîne clé, mais ce champ est déclaré comme un tableau d'un seul caractère. En fait, il s'agit d'une structure courante de longueur variable. Augmente la flexibilité. Voici le code à appliquer pour l'espace lors de l'insertion de nouveaux éléments dans la table de hachage

p = (Bucket *) pemalloc(sizeof(Bucket) - 1 + nKeyLength, ht->persistent);
if (!p) {
  return FAILURE;
}
memcpy(p->arKey, arKey, nKeyLength);

Diagramme du processus d'insertion

Algorithme de hachage

La fonction de hachage en php est implémentée à l'aide de l'algorithme DJBX33A.

Objet :

Les objets PHP sont stockés en utilisant la structure de données zend_object_value

Résumé : Ce qui précède est tout le contenu de cet article, j'espère ; cela peut être utile à tout le monde, apprendre aide.

Recommandations associées :

Analyse d'exemples CURL de transfert de données en PHP

Partage d'exemples simples d'ajout de données à des fichiers XML dans PHP

Exemple d'outil d'indexation d'analyse d'annuaire de sites Web basé sur 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!