PHP源碼之implode函數源碼怎么用

這篇文章將為大家詳細講解有關PHP源碼之implode函數源碼怎么用，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

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 擴展。但我正努力朝那個方向走呢！

• 在循環內，對數組單元分為三類：

  • 字符串
  • 整形數據
  • 其它
• 事實上，在循環開始之前，源碼中，先申請了一塊內存，用于存放下面的結構體，并且個數恰好是 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源碼之implode函數源碼怎么用就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。