PHP數組的內部實現你瞭解嗎

/*
* 其在 大端和小端 使用瞭不同的順序定義. 
* 想來是為瞭解決大小端環境的問題, 保證在不同的設備上可以讀取到相同的位
*/
#ifdef WORDS_BIGENDIAN
# define ZEND_ENDIAN_LOHI_3(lo, mi, hi)    hi; mi; lo;
#else
# define ZEND_ENDIAN_LOHI_3(lo, mi, hi)    lo; mi; hi;
#endif
// 對不同變量類型的定義
/* Regular data types: Must be in sync with zend_variables.c. */
#define IS_UNDEF					0
#define IS_NULL						1
#define IS_FALSE					2
// ...
// 進行結構體的重命名
typedef struct _zval_struct     zval;
/*
* 變量聯合體定義.
* 此聯合體和保存各種類型的變量
*/
typedef union _zend_value {
    zend_long         lval; // 8B
    double            dval; // 8B
    zend_refcounted  *counted; // 引用計數. 8B
    zend_string      *str; // 字符串. 8B
    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; // 8B
} zend_value; // 綜上: 8B
// 變量的結構體
struct _zval_struct {
    // 使用 zend_value 聯合體保存當前元素的值. 8B
    zend_value        value;			/* value */
    /*
    * 用來保存變量類型
    * 這裡為什麼要使用聯合體呢?
    * 眾所周知, 聯合體中變量是共用內存的
    * 而其中的兩個內容都是4字節的.
    * 因此, 我認為是為瞭方便使用.
    * 在統一操作時可使用 type_info, 有可以通過結構體分別獲取每一位
    * (不過這隻是個人理解, 沒有進行求證)
    */
    union {
        uint32_t type_info; // 4B
        struct {
            ZEND_ENDIAN_LOHI_3(
                // 用來保存當前變量的類型. 也就是上面的一批定義. 1B
                zend_uchar    type,			/* active type */
                // 當前變量的一些標志位. 如: 常量類型/不可修改 等等. 1B
                zend_uchar    type_flags,
                union { // 2B
                uint16_t  extra;        /* not further specified */
            } u)
        } v; // 4B
    } u1; // 4B
    // 上面兩個結構體共占用 12B, 而內存對其需要16B, 因此有4個字節是空著的
    // 下面的聯合體可以將這4B 充分利用.
    // 這裡根據不同的變量類型使用不同的變量. 比如: next, 在下面介紹數組的時候有用
    union {
        uint32_t     next;                 /* hash collision chain */
        uint32_t     cache_slot;           /* cache slot (for RECV_INIT) */
        uint32_t     opline_num;           /* opline number (for FAST_CALL) */
        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     property_guard;       /* single property guard */
        uint32_t     constant_flags;       /* constant flags */
        uint32_t     extra;                /* not further specified */
    } u2;
};

typedef struct _zend_array      zend_array;
// 沒毛病, 數組的別名就是 hashTable
typedef struct _zend_array HashTable;
// 用來保存數組中的數據
typedef struct _Bucket {
    // 當前元素值
    zval              val;
    // 當前元素的 hash
    zend_ulong        h;                /* hash value (or numeric index)   */
    // 元素的 key
    zend_string      *key;              /* string key or NULL for numerics */
} Bucket;
typedef struct _zend_array HashTable;
struct _zend_array {
    zend_refcounted_h gc; // 對數組進行引用計數. 8B
    union {
        struct {
            ZEND_ENDIAN_LOHI_4(
                /*
                * 標志位. 其常量定義如下:
                * #define HASH_FLAG_CONSISTENCY      ((1<<0) | (1<<1))
                * #define HASH_FLAG_PACKED           (1<<2)
                * #define HASH_FLAG_UNINITIALIZED    (1<<3)
                * #define HASH_FLAG_STATIC_KEYS      (1<<4) // long and interned strings
                * #define HASH_FLAG_HAS_EMPTY_IND    (1<<5)
                * #define HASH_FLAG_ALLOW_COW_VIOLATION (1<<6)
                */
                zend_uchar    flags,
                zend_uchar    _unused,
                zend_uchar    nIteratorsCount,
                zend_uchar    _unused2)
        } v;
        uint32_t flags; // 4B
    } u; // 4B
    // 用來保存數組中的元素信息. 這是一個數組, 記錄數組首地址.
    // 關於這裡的 兩個數組為什麼使用 聯合體記錄, 在上圖中解釋瞭. 
    union {
        // 用來讀取上方的 hashList 8B
        uint32_t     *arHash;   /* hash table (allocated above this pointer) */
        // 用來讀取上方的 dataList 8B
        Bucket       *arData;   /* array of hash buckets */
        // 當前數組中其實保存瞭兩個數組, 但是對於key是連續數字的數組來說, arrHash 其實並不需要. 可以直接使用數組存儲
        // 所以使用瞭 arPacked 來表示key全部為數字的, 通過標識位 HASH_FLAG_PACKED 來標識. 以節省內存占用
        // 所以, 其實對於連續數字的數組, 其底層真的是數組, 而不是 hashTable
        // 這裡你可以簡單的實驗一下, 通過構造一個連續數字索引的數字, 然後在給其賦值一個key 為字符串的元素, 通過 memory_get_usage 函數查看內存的變化. 很明顯的. 
        zval         *arPacked; /* packed array of zvals */
    }; // 8B
    // 數組中存儲的元素個數. 4B
    uint32_t          nNumOfElements;
    /*
    * 向數組中添加元素時, 使用的數組索引. 
    * 此變量與 nNumOfElements 的區別是,
    * 當數組中元素釋放的時候, 比如 unset 操作.
    * nNumOfElements 進行減一操作, 而 nNumUsed 變量不變.
    * 同時, 元素也並沒有從數組中抹去, 僅僅是將其 type 修改為 IS_UNDEF
    * 等到下一次內存擴充的時候, 在將這些元素釋放掉, 以保證釋放的高效
    * 4B
    */
    uint32_t          nNumUsed;
    // 記錄當前數組已經分配的地址大小. 2的 n 次冪(分配地址每次乘2). 4B
    uint32_t          nTableSize;
    // 計算 key 的 hash 散列值時使用(在下方具體介紹). 4B
    uint32_t          nTableMask;
    // 數組遍歷是使用的遊標, 如調用函數: next/prev/end/reset/current 等. 4B
    uint32_t          nInternalPointer;
    /*
    * 用來記錄下一個元素插入時的默認 key.
    * 比如代碼:
    * $arr = [];
    * $arr[] = 1; // 相當於 $arr[0]=1;
    * 但是, 你或許會疑惑, 這還需要單獨記錄麼? 直接使用數組的大小計算不就行瞭?
    * 再看一段:
    * $arr = [];
    * $arr['a'] = 1;
    * $arr[] = 2; // 相當於 $arr[0] = 1;
    * 是不是懂瞭??
    * 8B
    */
    zend_long         nNextFreeElement;
    /*
    * 此方法在數組中的元素更新或刪除時調用.
    * 若元素是引用計數的類型, 會更新其引用計數
    * 相當於元素的析構函數
    * 8B
    */
    dtor_func_t       pDestructor;
}; // 56B

//  判斷需要時對數組進行擴容
#define ZEND_HASH_IF_FULL_DO_RESIZE(ht)				\
    if ((ht)->nNumUsed >= (ht)->nTableSize) {		\
        zend_hash_do_resize(ht);					\
    }
static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_string *key, zval *pData, uint32_t flag)
{
    // 一些額外處理...
    // 需要時對數組進行擴充
    ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */
add_to_hash:
    // INTERNED 字符串不會被銷毀, 用來實現相同字符串共用內存
    // 當數組中所有key 都是 INTERNED 字符串
    // 那麼數組釋放的時候就不需要釋放 key 瞭, 同時數組 copy 的時候也不需要增加字符串引用計數
    // HASH_FLAG_STATIC_KEYS 標記位就是用來標記數組中所有 key 均為 INTERNED 字符串
    // 若當前字符串不是 INTERNED 的, 則修改數組的標記位
    if (!ZSTR_IS_INTERNED(key)) {
        zend_string_addref(key);
        HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
    }
    // 獲取當前元素的 dataList index
    idx = ht->nNumUsed++;
    // 數組中元素內容增加
    ht->nNumOfElements++;
    // 元素賦值
    arData = ht->arData;
    p = arData + idx;
    p->key = key;
    p->h = h = ZSTR_H(key);
    // 計算 hashList index
    nIndex = h | ht->nTableMask;
    // 這一步就是用來處理 hash 沖突的
    // 將當前元素的 next 指向原來 hashList 中的值
    Z_NEXT(p->val) = HT_HASH_EX(arData, nIndex);
    // 更新 hashList
    HT_HASH_EX(arData, nIndex) = HT_IDX_TO_HASH(idx);
    // 對 val 進行賦值. 
    // 這裡判斷標志位 HASH_LOOKUP, 然後將 val 置為 null. 這裡看瞭半天沒看懂其作用, 如果有知道的還望不吝賜教
    if (flag & HASH_LOOKUP) {
        ZVAL_NULL(&p->val);
    } else {
        ZVAL_COPY_VALUE(&p->val, pData);
    }
    return &p->val;
}

<?php
// 統計函數的耗時
function echoCallCostTime($msg, $call){
    $startTime = microtime(true) * 1000;
    $call();
    $endTime = microtime(true) * 1000;
    $diffTime = $endTime - $startTime;
    echo "$msg 耗時 $diffTime", PHP_EOL;
}
$size = 2**16;
$array = [];
echoCallCostTime('異常數組-構造', function () use ($size, &$array){
    $array = array();
    for ($i = 0; $i <= $size; $i++) {
        $key = $size * $i;
        $array[$key] = 0;
    }
});
echoCallCostTime('異常數組-首個元素訪問', function () use ($array){
    $b = $array[0];
});
echoCallCostTime('異常數組-最後元素訪問', function () use ($array, $size){
    $b = $array[$size * $size];
});
echoCallCostTime('普通數組-構造', function () use ($size, &$array){
    $array = array();
    for ($i = 0; $i <= $size; $i++) {
        $array[$i] = 0;
    }
});
echoCallCostTime('普通數組-首個元素訪問', function () use ($array){
    $b = $array[0];
});
echoCallCostTime('普通數組-最後元素訪問', function () use ($array, $size){
    $b = $array[$size];
});