PHP原始碼—implode函數原始碼分析

2020-07-16 10:05:35

PHP 中的 implode

  • 在 PHP 中,implode 的作用是:將一個一維陣列的值轉化為字串。記住一維陣列,如果是多維的,會發生什麼呢?在本篇分析中,會有所探討。
  • 事實上,通過官方的文件可以知道,implode 有兩種用法,通過函數簽名可以看得出來:
// 方法1
implode ( string $glue , array $pieces ) : string
// 方法2
implode ( array $pieces ) : string
  • 因為,在不傳 glue 的時候,內部實現會預設空字串。
  • 通過一個簡單的範例可以看出:
$pieces = [
    123,
    ',是一個',
    'number!',
];
$str1 = implode($pieces);
$str2 = implode('', $pieces);

var_dump($str1, $str2);
/*
string(20) "123,是一個number!"
string(20) "123,是一個number!"
*/

implode 原始碼實現

  • 通過搜尋鍵碼 PHP_FUNCTION(implode) 可以找到,該函數定義於 extstandardstring.c 檔案中的 1288 行
  • 一開始的幾行是引數宣告相關的資訊。其中 *arg2 是用於接收 pieces 引數的指標。
  • 在下方對 arg2 的判斷中,如果 arg2 為空,則表示沒有傳 pieces 對應的值
if (arg2 == NULL) {
    if (Z_TYPE_P(arg1) != IS_ARRAY) {
        php_error_docref(NULL, E_WARNING, "Argument must be an array");
        return;
    }

    glue = ZSTR_EMPTY_ALLOC();
    tmp_glue = NULL;
    pieces = arg1;
} else {
    if (Z_TYPE_P(arg1) == IS_ARRAY) {
        glue = zval_get_tmp_string(arg2, &tmp_glue);
        pieces = arg1;
    } else if (Z_TYPE_P(arg2) == IS_ARRAY) {
        glue = zval_get_tmp_string(arg1, &tmp_glue);
        pieces = arg2;
    } else {
        php_error_docref(NULL, E_WARNING, "Invalid arguments passed");
        return;
    }
}

不傳遞 pieces 引數

  • 在不傳遞 pieces 引數的判斷中,即 arg2 == NULL,主要是對引數的一些處理
  • 將 glue 初始化為空字串,並將傳進來的唯一的引數,賦值給 pieces 變數,接著就呼叫 php_implode(glue, pieces, return_value);

十分關鍵的 php_implode

  • 無論有沒有傳遞 pieces 引數,在處理好引數後,最終都會呼叫 PHPAPI 的相關函數 php_implode,可見,關鍵邏輯都是在這個函數中實現的,那麼我們深入其中看一看它
  • 在呼叫 php_implode 時,出現了一個看起來沒有被宣告的變數 return_value。沒錯,它似乎就是憑空出現的
  • 通過谷歌搜尋 PHP原始碼中 return_value,找到了答案
  • 原來,這個變數是伴隨著宏 PHP_FUNCTION 而出現的,而此處 implode 的實現就是通過 PHP_FUNCTION(implode) 來宣告的。而 PHP_FUNCTION 的定義是:
#define PHP_FUNCTION            ZEND_FUNCTION
// 對應的 ZEND_FUNCTION 定義如下
#define ZEND_FUNCTION(name)                ZEND_NAMED_FUNCTION(ZEND_FN(name))
// 對應的 ZEND_NAMED_FUNCTION 定義如下
#define ZEND_NAMED_FUNCTION(name)        void ZEND_FASTCALL name(INTERNAL_FUNCTION_PARAMETERS)
// 對應的 ZEND_FN 定義如下
#define ZEND_FN(name) zif_##name
// 對應的 ZEND_FASTCALL 定義如下
# define ZEND_FASTCALL __attribute__((fastcall))
  • (關於雙井號,它起連線符的作用,可以參考這裡了解)
  • 在被預處理後,它的樣子類似於下方所示:
void zif_implode(int ht, zval *return_value, zval **return_value_ptr, zval *this_ptr, int return_value_used TSRMLS_DC)
  • 也就是說 return_value 是作為整個 implode 擴充套件函數定義的一個形參
  • 在 php_implode 的定義中,一開始,先定義了一些即將用到的變數,隨後使用 ALLOCA_FLAG(use_heap) 進行標識,如果申請記憶體,則申請的是堆記憶體
  • 通過 numelems = zend_hash_num_elements(Z_ARRVAL_P(pieces)); 獲取 pieces 引數的單元數量,如果是空陣列,則直接返回空字串
  • 此處還有判斷,如果陣列單元數為 1,則直接將唯一的單元作為字串返回。
  • 最後是處理多陣列單元的情況,因為前面標識過,若申請記憶體則申請的是堆記憶體,堆記憶體相對於棧來講,效率比較低,所以只在非用不可的情形下,才會申請堆記憶體,那此處的情形就是多單元陣列的情況。
  • 隨後,針對 pieces 迴圈,獲取其值進行拼接,在原始碼中的 foreach 迴圈是固定結構,如下:
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(zend_array), tmp) {
    // ...
} ZEND_HASH_FOREACH_END();
  • 這種常用寫法我覺得,在編寫 PHP 擴充套件中是必不可少的吧。雖然我還沒有編寫過任何一個可用於生產環境的 PHP 擴充套件。但我正努力朝那個方向走呢!
  • 在迴圈內,對陣列單元分為三類:

    • 字串
    • 整形資料
    • 其它
  • 事實上,在迴圈開始之前,原始碼中,先申請了一塊記憶體,用於存放下面的結構體,並且個數恰好是 pieces 陣列單元的個數。
struct {
    zend_string *str;
    zend_long    lval;
} *strings, *ptr;
  • 可以看到,結構體成員包含 zend 字串以及 zend 整形資料。這個結構體的出現,恰好是為了存放陣列單元中的 zend 字串/zend 整形資料。

字串

  • 先假設,pieces 陣列單元中,都是字串型別,此時迴圈中執行的邏輯就是:
// tmp 是迴圈中的單元值
ptr->str = Z_STR_P(tmp);
len += ZSTR_LEN(ptr->str);
ptr->lval = 0;
ptr++;
  • 其中,tmp 是迴圈中的單元值。每經歷一次迴圈,會將單元值放入結構體中,隨後進行指標 +1 運算,指標就指向儲存下一個結構體資料的地址:
  • 並且,在這期間,統計出了字串的總長度 len += ZSTR_LEN(ptr->str);

整數型別

  • 以上,討論了陣列單元中是字串的情況。接下來看看,如果陣列單元的型別是數值型別時會發生什麼?
  • 判斷一個變數是否是數值型別(其實是 zend_long),通用方法是:Z_TYPE_P(tmp) == IS_LONG。一旦知道當前的資料型別是 zend_long,則將其賦值給 ptr 的 lval 結構體成員。然後 ptr 指標後移一個單位長度。
  • 但是,我們知道我們不能像獲取 zend_string 的長度一樣去獲取 zend_long 的字元長度。如果是 zend_string,則可以通過 len += ZSTR_LEN(val); 的方式獲取其字元長度。對於 zend_long,有什麼好的方法呢?
  • 在原始碼中是通過對 10 做除法運算,得出結果的一部分,再慢慢的累加其長度:
while (val) {
    val /= 10;
    len++;
}
  • 如果是負數呢?沒有什麼特別的辦法,直接判斷處理:
if (val <= 0) {
    len++;
}

字串的處理和拷貝

  • 迴圈結束後,ptr 就是指向這段記憶體的尾部的指標。
  • 然後,申請了一段記憶體:str = zend_string_safe_alloc(numelems - 1, ZSTR_LEN(glue), len, 0);,用於存放單元字串總長度加上連線字元的總長度,即 (n-1)glue + len。因為 n 個陣列單元,只需要 n-1 個 glue 字串。然後,將這段記憶體的尾地址,賦值給 cptr,為什麼要指向尾部呢?看下一部分,你就會明白了。
  • 接下來,需要迴圈取出存放在 ptr 中的字元。我們知道,ptr 此時是所處記憶體區域的尾部,為了能有序展示連線的字串,原始碼中,是從後向前迴圈處理。這也就是為什麼需要把 cptr 指向所在記憶體區域的尾部的原因。
  • 進入迴圈,先進行 ptr--;,然後針對 ptr->str 的判斷 if (EXPECTED(ptr->str)),看了一下此處的 EXPECTED 的作用,可以參考這裡。可以簡單的將其理解一種組合層面的優化,當實際執行的情況更偏向於當前條件下的分支而非 else 的分支時,就用 EXPECTED 宏將其包裝起來:EXPECTED(ptr->str)。我敢說,當你呼叫 implode 傳遞的陣列中都是數位而非字串,那麼這裡的 EXPECTED 作用就會失效。
  • 接下來的兩行是比較核心的:
cptr -= ZSTR_LEN(ptr->str);
memcpy(cptr, ZSTR_VAL(ptr->str), ZSTR_LEN(ptr->str));
  • cptr 的指標前移一個陣列單元字元的長度,然後將 ptr->str (某陣列單元的值)通過 c 標準庫函數 memcpy 拷貝到 cptr 記憶體空間中。
  • ptr == strings 滿足時,意味著 ptr 不再有可被複製的字串/數位。因為 strings 是 ptr 所在區域的首地址。
  • 通過上面,已經成功將一個陣列單元的字串拷貝到 cptr 對應的記憶體區域中,接下來如何處理 glue 呢?
  • 只需要像處理 ptr->str 一樣處理 glue 即可。至少原始碼中是這麼做的。
  • 程式碼中有一段是:*cptr = 0,它的作用相當於賦值空字串。
  • cptr 繼續前移 glue 的長度,然後,將 glue 字串拷貝到 cptr 對應的記憶體區域中。沒錯,還是用 memcpy 函數。
  • 到這裡,第一次迴圈結束了。我應該不需要像實際迴圈中那樣描述這裡的迴圈吧?相信優秀的你,是完全可以參考上方的描述腦補出來的 ^^
  • 當然,處理返回的兩句還是要提一下:
free_alloca(strings, use_heap);
RETURN_NEW_STR(str);
  • strings 的那一片記憶體空間只是儲存臨時值的,因此函數結束了,就必須跟 strings 說再見。我們知道 c 語言是手動管理記憶體的,沒有 GC,你要顯示的釋放記憶體,即 free_alloca(strings, use_heap);
  • 在上面的描述中,我們只講到了 cptr,但這裡的返回值卻是 str。
  • 不用懷疑,這裡是對的,我們所講的 cptr 那一片記憶體區域的首地址就是 str。並通過宏 RETURN_NEW_STR 會將最終的返回值寫入 return_value 中

實踐

  • 為了可能更加清晰 implode 原始碼中程式碼執行時的情況,接下來,我們通過 PHP 擴充套件的方式對其進行 debug。在這個過程中的程式碼,我都放在 GitHub 的倉庫中,分支名是 debug/implode,可自行下載執行,看看效果。
  • 新建 PHP 擴充套件模板的操作,可以參考這裡。請確保操作完裡面描述的步驟。
  • 接下來,主要針對 su_dd.c 檔案修改程式碼。為了能通過修改程式碼來看效果,將 php_implode 函數複製到擴充套件檔案中,並將其命名為 su_php_implode:
static void su_php_implode(const zend_string *glue, zval *pieces, zval *return_value)
{
    // 原始碼內容省略
}
  • 在擴充套件中新增一個擴充套件函數 su_test:
PHP_FUNCTION(su_test)
{
    zval tmp;
    zend_string *str, *glue, *tmp_glue;
    zval *arg1, *arg2 = NULL, *pieces;

    ZEND_PARSE_PARAMETERS_START(1, 2)
        Z_PARAM_ZVAL(arg1)
        Z_PARAM_OPTIONAL
        Z_PARAM_ZVAL(arg2)
    ZEND_PARSE_PARAMETERS_END();
    glue = zval_get_tmp_string(arg1, &tmp_glue);
    pieces = arg2;
    su_php_implode(glue, pieces, return_value);
}
  • 因為擴充套件的編譯以及引入,前面的已經提及。因此,此時只需編寫 PHP 程式碼進行呼叫:
// t1.php
$res = su_test('-', [
    2019, '01', '01',
]);
var_dump($res);
  • PHP 執行該指令碼,輸出:string(10) "2019-01-01",這意味著,你已經成功編寫了一個擴充套件函數。別急,這只是邁出了第一步,別忘記我們的目標:通過偵錯來學習 implode 原始碼。
  • 接下來,我們通過 gdb 工具,偵錯以上 PHP 程式碼在原始碼層面的執行。為了防止初學者不會用 gdb,這裡就繁瑣的寫出這個過程。如果沒有安裝 gdb,請自行谷歌。
  • 先進入 PHP 指令碼所在路徑。命令列下:
gdb php
b zval_get_tmp_string
r t1.php
  • b 即 break,表示打一個斷點
  • r 即 run,表示執行指令碼
  • s 即 step,表示一步一步偵錯,遇到方法呼叫,會進入方法內部單步偵錯
  • n 即 next,表示一行一行偵錯。遇到方法,則偵錯直接略過直接執行返回,偵錯不會進入其內部。
  • p 即 print,表示列印當前作用域中的一個變數
  • 當執行完 r t1.php,則會定位到第一個斷點對應的行,顯示如下:
Breakpoint 1, zif_su_test (execute_data=0x7ffff1a1d0c0, 
    return_value=0x7ffff1a1d090)
    at /home/www/clang/php-7.3.3/ext/su_dd/su_dd.c:179
179        glue = zval_get_tmp_string(arg1, &tmp_glue);
  • 此時,按下 n,顯示如下:
184        su_php_implode(glue, pieces, return_value);
  • 此時,當前的作用域中存在變數:gluepiecesreturn_value
  • 我們可以通過 gdb 偵錯,檢視 pieces 的值。先使用命令:p pieces,此時在終端會顯示類似於如下內容:
$1 = (zval *) 0x7ffff1a1d120
  • 表明 pieces 是一個 zval 型別的指標,0x7ffff1a1d120 是其地址,當然,你執行的時候對應的也是一個地址,只不過跟我的這個會不太一樣。
  • 我們繼續使用 p 去列印儲存於改地址的變數內容:p *$1,$1 可以認為是一個臨時變數名,* 是取值運算子。執行完後,此時顯示如下:
(gdb) p *$1
$2 = {value = {lval = 140737247576960, dval = 6.9533439118030153e-310, 
    counted = 0x7ffff1a60380, str = 0x7ffff1a60380, arr = 0x7ffff1a60380, 
    obj = 0x7ffff1a60380, res = 0x7ffff1a60380, ref = 0x7ffff1a60380, 
    ast = 0x7ffff1a60380, zv = 0x7ffff1a60380, ptr = 0x7ffff1a60380, 
    ce = 0x7ffff1a60380, func = 0x7ffff1a60380, ww = {w1 = 4054188928, 
      w2 = 32767}}, u1 = {v = {type = 7 'a', type_flags = 1 '01', u = {
        call_info = 0, extra = 0}}, type_info = 263}, u2 = {next = 0, 
    cache_slot = 0, opline_num = 0, lineno = 0, num_args = 0, fe_pos = 0, 
    fe_iter_idx = 0, access_flags = 0, property_guard = 0, constant_flags = 0, 
    extra = 0}}
  • 列印的內容,看起來是一堆亂糟糟的字元,這實際上是 zval 的結構體,其中的欄位剛好是和 zval 的成員一一對應的,為了便於讀者閱讀,這裡直接貼出 zval 的結構體資訊:
struct _zval_struct {
    zend_value        value;            /* value */
    union {
        struct {
            ZEND_ENDIAN_LOHI_3(
                zend_uchar    type,            /* active type */
                zend_uchar    type_flags,
                union {
                    uint16_t  call_info;    /* call info for EX(This) */
                    uint16_t  extra;        /* not further specified */
                } u)
        } v;
        uint32_t type_info;
    } u1;
    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     access_flags;         /* class constant access flags */
        uint32_t     property_guard;       /* single property guard */
        uint32_t     constant_flags;       /* constant flags */
        uint32_t     extra;                /* not further specified */
    } u2;
};
  • 我們直指要害 —— value,列印一下其中的內容。列印結構體成員可以使用 . 運算子,例如:p $2.value,執行這個命令,顯示如下:
(gdb) p $2.value
$3 = {lval = 140737247576960, dval = 6.9533439118030153e-310, 
  counted = 0x7ffff1a60380, str = 0x7ffff1a60380, arr = 0x7ffff1a60380, 
  obj = 0x7ffff1a60380, res = 0x7ffff1a60380, ref = 0x7ffff1a60380, 
  ast = 0x7ffff1a60380, zv = 0x7ffff1a60380, ptr = 0x7ffff1a60380, 
  ce = 0x7ffff1a60380, func = 0x7ffff1a60380, ww = {w1 = 4054188928, 
    w2 = 32767}}
  • 通過 zval 結構體,我們知道 value 成員的型別是 zend_value,很不幸,這也是一個結構體:
typedef union _zend_value {
    zend_long         lval;                /* long value */
    double            dval;                /* double value */
    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;
  • 我們要列印的變數是 pieces,我們知道它是一個陣列,因而此時我們直接取 zend_value 結構體的 *arr 成員,它外表看起來就是一個指標,因此列印其內容,需要使用 * 運算子
(gdb) p *$3.arr
$4 = {gc = {refcount = 2, u = {type_info = 23}}, u = {v = {flags = 28 '34', 
      _unused = 0 '00', nIteratorsCount = 0 '00', _unused2 = 0 '00'}, 
    flags = 28}, nTableMask = 4294967294, arData = 0x7ffff1a67648, 
  nNumUsed = 3, nNumOfElements = 3, nTableSize = 8, nInternalPointer = 0, 
  nNextFreeElement = 3, pDestructor = 0x555555b6e200 <zval_ptr_dtor>}
  • 真棒!到目前為止,貌似一切都按照預定的路線進行。通過 zend_value 結構體,可以知道 *arr 的型別是 zend_array:
struct _zend_array {
    zend_refcounted_h gc;
    union {
        struct {
            ZEND_ENDIAN_LOHI_4(
                zend_uchar    flags,
                zend_uchar    _unused,
                zend_uchar    nIteratorsCount,
                zend_uchar    _unused2)
        } 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;
};
  • 了解 PHP 陣列的同學一定知道它底層是一個 HashTable,感興趣的同學,可以去自行了解一下 HashTable。這裡,我們列印 *arData,使用:p *$4.arDaa:
(gdb) p *$4.arData
$5 = {val = {value = {lval = 2019, dval = 9.9751853895347677e-321, 
      counted = 0x7e3, str = 0x7e3, arr = 0x7e3, obj = 0x7e3, res = 0x7e3, 
      ref = 0x7e3, ast = 0x7e3, zv = 0x7e3, ptr = 0x7e3, ce = 0x7e3, 
      func = 0x7e3, ww = {w1 = 2019, w2 = 0}}, u1 = {v = {type = 4 '04', 
        type_flags = 0 '00', u = {call_info = 0, extra = 0}}, type_info = 4}, 
    u2 = {next = 0, cache_slot = 0, opline_num = 0, lineno = 0, num_args = 0, 
      fe_pos = 0, fe_iter_idx = 0, access_flags = 0, property_guard = 0, 
      constant_flags = 0, extra = 0}}, h = 0, key = 0x0}
  • 到這裡,我們已經可以看到 pieces 陣列第一個單元的值 —— 2019,就是那段 lval = 2019
  • 好了,關於 gdb 的簡單使用就先介紹到這裡。文章開篇,我們提到,如果陣列是多維陣列,會發生什麼?我們實踐的主要目標就是簡單實現二維陣列的 implode
  • 在 PHP 的 implode 函數中,如果是多維陣列,則會直接把裡層的陣列顯示為 Array 字串。
$res = implode('-', [
    2019, '01', '01', [1,2]
]);
var_dump($res);
  • 執行這段指令碼,會輸出如下:
PHP Notice:  Array to string conversion in /path/to/t2.php on line 3
PHP Notice:  Array to string conversion in /path/to/t2.php on line 3
string(16) "2019-01-01-Array"
  • 為了能夠支援連線陣列,我們需要改寫 php_implode,因此,先拷貝一下 php_implode 到寫擴充套件程式碼的檔案中:
PHPAPI void php_implode(const zend_string *glue, zval *pieces, zval *return_value)
{
    zval         *tmp;
    int           numelems;
    zend_string  *str;
    char         *cptr;
    size_t        len = 0;
    struct {
        zend_string *str;
        zend_long    lval;
    } *strings, *ptr;
    ALLOCA_FLAG(use_heap)

    numelems = zend_hash_num_elements(Z_ARRVAL_P(pieces));

    if (numelems == 0) {
        RETURN_EMPTY_STRING();
    } else if (numelems == 1) {
        /* loop to search the first not undefined element... */
        ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pieces), tmp) {
            RETURN_STR(zval_get_string(tmp));
        } ZEND_HASH_FOREACH_END();
    }

    ptr = strings = do_alloca((sizeof(*strings)) * numelems, use_heap);

    ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pieces), tmp) {
        if (EXPECTED(Z_TYPE_P(tmp) == IS_STRING)) {
            ptr->str = Z_STR_P(tmp);
            len += ZSTR_LEN(ptr->str);
            ptr->lval = 0;
            ptr++;
        } else if (UNEXPECTED(Z_TYPE_P(tmp) == IS_LONG)) {
            zend_long val = Z_LVAL_P(tmp);

            ptr->str = NULL;
            ptr->lval = val;
            ptr++;
            if (val <= 0) {
                len++;
            }
            while (val) {
                val /= 10;
                len++;
            }
        } else {
            ptr->str = zval_get_string_func(tmp);
            len += ZSTR_LEN(ptr->str);
            ptr->lval = 1;
            ptr++;
        }
    } ZEND_HASH_FOREACH_END();

    /* numelems can not be 0, we checked above */
    str = zend_string_safe_alloc(numelems - 1, ZSTR_LEN(glue), len, 0);
    cptr = ZSTR_VAL(str) + ZSTR_LEN(str);
    *cptr = 0;

    while (1) {
        ptr--;
        if (EXPECTED(ptr->str)) {
            cptr -= ZSTR_LEN(ptr->str);
            memcpy(cptr, ZSTR_VAL(ptr->str), ZSTR_LEN(ptr->str));
            if (ptr->lval) {
                zend_string_release_ex(ptr->str, 0);
            }
        } else {
            char *oldPtr = cptr;
            char oldVal = *cptr;
            cptr = zend_print_long_to_buf(cptr, ptr->lval);
            *oldPtr = oldVal;
        }

        if (ptr == strings) {
            break;
        }

        cptr -= ZSTR_LEN(glue);
        memcpy(cptr, ZSTR_VAL(glue), ZSTR_LEN(glue));
    }

    free_alloca(strings, use_heap);
    RETURN_NEW_STR(str);
}
  • 先將函數簽名稍微調整成 static void su_php_implode(const zend_string *glue, zval *pieces, zval *return_value)
  • 我們可以看到其中有一段迴圈 pieces 的處理:
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pieces), tmp) {
        if (EXPECTED(Z_TYPE_P(tmp) == IS_STRING)) {
            // ...
        } else if (UNEXPECTED(Z_TYPE_P(tmp) == IS_LONG)) {
            // ...
        } else {
            // ...
        }
    } ZEND_HASH_FOREACH_END();
  • 我們只需將其中的 if 分支新增一個分支:else if (UNEXPECTED(Z_TYPE_P(tmp) == IS_ARRAY)),其具體內容如下:
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pieces), tmp) {
    if (EXPECTED(Z_TYPE_P(tmp) == IS_STRING)) {
        // ...
    } else if (UNEXPECTED(Z_TYPE_P(tmp) == IS_LONG)) {
        // ...
    } else if (UNEXPECTED(Z_TYPE_P(tmp) == IS_ARRAY)) {
        // 如果值是陣列,則呼叫 php_implode,將其使用 glue 連線成字串
        cptr = ZSTR_VAL(ptr->str);
        zend_string* str2 = origin_php_implode(glue, tmp, tmp_val);
        ptr->str = str2;
        // 此時,要拿到拼接後的字串長度
        len += ZSTR_LEN(str2);
        ptr++;
    } else {
        // ...
    }
} ZEND_HASH_FOREACH_END();
  • 正如注釋中寫的,當遇到陣列的單元是陣列型別時,我們會呼叫原先的 php_implode,只不過,這個「php_implode」會真的返回一個 zend_string 指標,在此我將其改名為 origin_php_implode
static zend_string* origin_php_implode(const zend_string *glue, zval *pieces, zval *return_value)
{
    zval         *tmp;
    int           numelems;
    zend_string  *str;
    char         *cptr;
    size_t        len = 0;
    struct {
        zend_string *str;
        zend_long    lval;
    } *strings, *ptr;
    ALLOCA_FLAG(use_heap)

    numelems = zend_hash_num_elements(Z_ARRVAL_P(pieces));

    if (numelems == 0) {
        RETURN_EMPTY_STRING();
    } else if (numelems == 1) {
        /* loop to search the first not undefined element... */
        ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pieces), tmp) {
            RETURN_STR(zval_get_string(tmp));
        } ZEND_HASH_FOREACH_END();
    }

    ptr = strings = do_alloca((sizeof(*strings)) * numelems, use_heap);

    ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pieces), tmp) {
        if (EXPECTED(Z_TYPE_P(tmp) == IS_STRING)) {
            ptr->str = Z_STR_P(tmp);
            len += ZSTR_LEN(ptr->str);
            ptr->lval = 0;
            ptr++;
        } else if (UNEXPECTED(Z_TYPE_P(tmp) == IS_LONG)) {
            zend_long val = Z_LVAL_P(tmp);

            ptr->str = NULL;
            ptr->lval = val;
            ptr++;
            if (val <= 0) {
                len++;
            }
            while (val) {
                val /= 10;
                len++;
            }
        } else {
            ptr->str = zval_get_string_func(tmp);
            len += ZSTR_LEN(ptr->str);
            ptr->lval = 1;
            ptr++;
        }
    } ZEND_HASH_FOREACH_END();

    /* numelems can not be 0, we checked above */
    str = zend_string_safe_alloc(numelems - 1, ZSTR_LEN(glue), len, 0);
    cptr = ZSTR_VAL(str) + ZSTR_LEN(str);
    *cptr = 0;

    while (1) {
        ptr--;
        if (EXPECTED(ptr->str)) {
            cptr -= ZSTR_LEN(ptr->str);
            memcpy(cptr, ZSTR_VAL(ptr->str), ZSTR_LEN(ptr->str));
            if (ptr->lval) {
                zend_string_release_ex(ptr->str, 0);
            }
        } else {
            char *oldPtr = cptr;
            char oldVal = *cptr;
            cptr = zend_print_long_to_buf(cptr, ptr->lval);
            *oldPtr = oldVal;
        }

        if (ptr == strings) {
            break;
        }

        cptr -= ZSTR_LEN(glue);
        memcpy(cptr, ZSTR_VAL(glue), ZSTR_LEN(glue));
    }

    free_alloca(strings, use_heap);
    // RETURN_NEW_STR(str);
    return str;
}
  • 內容大體不變,只有函數簽名以及返回值的地方略作調整了。
  • 配合前面的 PHP_FUNCTION(su_test),功能實現的差不多了。我們去編譯看看:
./configure
sudo make
sudo make install
  • 太棒了,編譯通過。我們去執行一下 PHP 指令碼:
$res = su_test('-', [
    2019, '01', '01', ['1', '2',],
]);
var_dump($res);
  • 輸出如下:
string(14) "2019-01-01-1-2"
  • 恭喜,我們已經大功告成!

以上就是PHP原始碼—implode函數原始碼分析的詳細內容,更多請關注TW511.COM其它相關文章!