PHP 源碼 — implode 函數源碼分析

時間 2019-11-07

標籤 php 源碼 implode 函數分析欄目 PHP 简体版

原文原文鏈接

本文首發於 https://github.com/suhanyujie...*

做者：suhanyujie

基於 PHP 7.3.3

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) 能夠找到，該函數定義於 \ext\standard\string.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 擴展。但我正努力朝那個方向走呢！
在循環內，對數組單元分爲三類：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);

此時，當前的做用域中存在變量：glue，pieces，return_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 '\001', 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 '\034', 
      _unused = 0 '\000', nIteratorsCount = 0 '\000', _unused2 = 0 '\000'}, 
    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 '\004', 
        type_flags = 0 '\000', 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 內核 http://www.php-internals.com/...
http://www.phppan.com/2010/02...
https://github.com/pangudashu...

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。