foreach 相關

20 Nov 08 深刻理解PHP原理之foreach 

• 做者: Laruence(   )
• 本文地址: http://www.laruence.com/2008/11/20/630.html
• 轉載請註明出處

foreach是PHP中很經常使用的一個用做數組循環的控制語句。
由於它的方便和易用，天然也就在後端隱藏着很複雜的具體實現方式(對用戶透明)
今天，咱們就來一塊兒分析分析，foreach是如何實現數組（對象）的遍歷的。
本節內容涉及到較多編譯原理（lex and yacc）的知識，因此若是您以爲看不太懂，能夠先找相關的資料看看。

咱們知道PHP是一個腳本語言，也就是說，用戶編寫的PHP代碼最終都是會被PHP解釋器解釋執行，
特別的，對於PHP來講，全部的用戶編寫的PHP代碼，都會被翻譯成PHP的虛擬機ZE的虛擬指令（OPCODES）來執行(參看：深刻理解PHP原理之Opcodes).

不論細節的話，就是說，咱們所編寫的任何PHP腳本，都會最終被翻譯成一條條的指令，從而根據指令，由相應的C編寫的函數來執行。

那麼foreach會被翻譯成什麼樣子呢？

1. foreach($arr as $key => $val){
2.      echo $key . '=>' . $val . "\n";
3. }

 

在詞法分析階段，foreach會被識別爲一個TOKEN：T_FOREACH，
在語法分析階段，會被規則：

1.   unticked_statement: //沒有被綁定ticks的語句
2.      //有省略
3.     | T_FOREACH '(' variable T_AS
4.         { zend_do_foreach_begin(&$1, &$2, &$3, &$4, 1 TSRMLS_CC); }
5.         foreach_variable foreach_optional_arg ')' { zend_do_foreach_cont(&$1, &$2, &$4, &$6, &$7 TSRMLS_CC); }
6.         foreach_statement { zend_do_foreach_end(&$1, &$4 TSRMLS_CC); }
7.     | T_FOREACH '(' expr_without_variable T_AS
8.         { zend_do_foreach_begin(&$1, &$2, &$3, &$4, 0 TSRMLS_CC); }
9.         variable foreach_optional_arg ')' { zend_check_writable_variable(&$6); zend_do_foreach_cont(&$1, &$2, &$4, &$6, &$7 TSRMLS_CC); }
10.         foreach_statement { zend_do_foreach_end(&$1, &$4 TSRMLS_CC); }
11.      //有省略
12. ;

仔細分析這段語法規則，咱們能夠發現，對於:
foreach($arr as $key => $val){
echo $key . ‘=>’ . $val .」\n」;
}

會被分析爲：

1.      T_FOREACH '(' variable T_AS { zend_do_foreach_begin('foreach', '(', $arr, 'as', 1 TSRMLS_CC); }
2.     foreach_variable foreach_optional_arg(T_DOUBLE_ARROW foreach_variable) ')' { zend_do_foreach_cont('foreach', '(', 'as', $key, $val TSRMLS_CC); }
3.     foreach_satement {zend_do_foreach_end('foreach', 'as');}

而後，讓咱們來看看foreach_statement：
它其實就是一個代碼塊，體現了咱們的 echo $key . ‘=>’ . $val .」\n」;
T_ECHO expr;

顯然，實現foreach的核心就是以下3個函數：
zend_do_foreach_begin
zend_do_foreach_cont
zend_do_foreach_end

其中，zend_do_foreach_begin (代碼太長，直接寫僞碼) 主要作了：
1. 記錄當前的opline行數（爲之後跳轉而記錄）
2. 對數組進行RESET（講內部指針指向第一個元素）
3. 獲取臨時變量 （$val）
4. 設置獲取變量的OPCODE FE_FETCH，結果存第3步的臨時變量
4. 記錄獲取變量的OPCODES的行數

而對於 zend_do_foreach_cont來講：
1. 根據foreach_variable的u.EA.type來判斷是否引用
2. 根據是否引用來調整zend_do_foreach_begin中生成的FE_FETCH方式
3. 根據zend_do_foreach_begin中記錄的取變量的OPCODES的行數，來初始化循環(主要處理在循環內部的循環:do_begin_loop)

最後zend_do_foreach_end:
1. 根據zend_do_foreach_begin中記錄的行數信息，設置ZEND_JMP OPCODES
2. 根據當前行數，設置循環體下一條opline, 用以跳出循環
3. 結束循環（處理循環內循環:do_end_loop)
4. 清理臨時變量

固然， 在zend_do_foreach_cont 和 zend_do_foreach_end之間 會在語法分析階段被填充foreach_satement的語句代碼。

這樣，就實現了foreach的OPCODES line。
好比對於咱們開頭的實例代碼，最終生成的OPCODES是：

1. filename: /home/huixinchen/foreach.php
2. function name: (null)
3. number of ops: 17
4. compiled vars: !0 = $arr, !1 = $key, !2 = $val
5. line # op fetch ext return operands
6. -------------------------------------------------------------------------------
7.    2 0 SEND_VAL 1
8.          1 SEND_VAL 100
9.          2 DO_FCALL 2 'range'
10.          3 ASSIGN !0, $0
11.    3 4 FE_RESET $2 !0, ->14
12.          5 FE_FETCH $3 $2, ->14
13.          6 ZEND_OP_DATA ~5
14.          7 ASSIGN !2, $3
15.          8 ASSIGN !1, ~5
16.    4 9 CONCAT ~7 !1, '-'
17.         10 CONCAT ~8 ~7, !2
18.         11 CONCAT ~9 ~8, '%0A'
19.         12 ECHO ~9
20.    5 13 JMP ->5
21.         14 SWITCH_FREE $2
22.    7 15 RETURN 1
23.         16* ZEND_HANDLE_EXCEPTION

咱們注意到FE_FETCH的op2的操做數是14，也就是JMP後一條opline，也就是說，在獲取完最後一個數組元素之後，FE_FETCH失敗的狀況下，會跳到第14行opline，從而實現了循環的結束。
而15行opline的op1的操做數是指向了FE_FETCH，也就是無條件跳轉到第5行opline，從而實現了循環。

附錄:

1. void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC)
2. {
3.     zend_op *opline;
4.     zend_bool is_variable;
5.     zend_bool push_container = 0;
6.     zend_op dummy_opline;
7.  
8.     if (variable) {
9.           //是不是匿名數組
10.         if (zend_is_function_or_method_call(array)) {
11.                //是不是函數返回值
12.             is_variable = 0;
13.         } else {
14.             is_variable = 1;
15.         }
16.         /* 使用括號記錄FE_RESET的opline行數 */
17.         open_brackets_token->u.opline_num = get_next_op_number(CG(active_op_array));
18.         zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); //獲取數組/對象和zend_do_begin_variable_parse對應
19.         if (CG(active_op_array)->last > 0 &&
20.             CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode == ZEND_FETCH_OBJ_W) {
21.             /* Only lock the container if we are fetching from a real container and not $this */
22.             if (CG(active_op_array)->opcodes[CG(active_op_array)->last-1].op1.op_type == IS_VAR) {
23.                 CG(active_op_array)->opcodes[CG(active_op_array)->last-1].extended_value |= ZEND_FETCH_ADD_LOCK;
24.                 push_container = 1;
25.             }
26.         }
27.     } else {
28.         is_variable = 0;
29.         open_brackets_token->u.opline_num = get_next_op_number(CG(active_op_array));
30.     }
31.  
32.     foreach_token->u.opline_num = get_next_op_number(CG(active_op_array)); //記錄數組Reset Opline number
33.  
34.     opline = get_next_op(CG(active_op_array) TSRMLS_CC); //生成Reset數組Opcode
35.  
36.     opline->opcode = ZEND_FE_RESET;
37.     opline->result.op_type = IS_VAR;
38.     opline->result.u.var = get_temporary_variable(CG(active_op_array));
39.     opline->op1 = *array;
40.     SET_UNUSED(opline->op2);
41.     opline->extended_value = is_variable ? ZEND_FE_RESET_VARIABLE : 0;
42.  
43.     dummy_opline.result = opline->result;
44.     if (push_container) {
45.         dummy_opline.op1 = CG(active_op_array)->opcodes[CG(active_op_array)->last-2].op1;
46.     } else {
47.         znode tmp;
48.  
49.         tmp.op_type = IS_UNUSED;
50.         dummy_opline.op1 = tmp;
51.     }
52.     zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op));
53.  
54.     as_token->u.opline_num = get_next_op_number(CG(active_op_array)); //記錄循環起始點
55.  
56.     opline = get_next_op(CG(active_op_array) TSRMLS_CC);
57.     opline->opcode = ZEND_FE_FETCH;
58.     opline->result.op_type = IS_VAR;
59.     opline->result.u.var = get_temporary_variable(CG(active_op_array));
60.     opline->op1 = dummy_opline.result; //被操做數組
61.     opline->extended_value = 0;
62.     SET_UNUSED(opline->op2);
63.  
64.     opline = get_next_op(CG(active_op_array) TSRMLS_CC);
65.     opline->opcode = ZEND_OP_DATA; //當使用key的時候附屬操做數,當foreach中不包含key時忽略
66.     SET_UNUSED(opline->op1);
67.     SET_UNUSED(opline->op2);
68.     SET_UNUSED(opline->result);
69. }

1. void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC)
2. {
3.     zend_op *opline;
4.     znode dummy, value_node;
5.     zend_bool assign_by_ref=0;
6.  
7.     opline = &CG(active_op_array)->opcodes[as_token->u.opline_num]; //獲取FE_FETCH Opline
8.     if (key->op_type != IS_UNUSED) {
9.         znode *tmp;//交換key和val
10.  
11.         tmp = key;
12.         key = value;
13.         value = tmp;
14.  
15.         opline->extended_value |= ZEND_FE_FETCH_WITH_KEY; //代表須要同時獲取key和val
16.     }
17.  
18.     if ((key->op_type != IS_UNUSED) && (key->u.EA.type & ZEND_PARSED_REFERENCE_VARIABLE)) {
19.           //key不能以引用方式獲取
20.         zend_error(E_COMPILE_ERROR, "Key element cannot be a reference");
21.     }
22.  
23.     if (value->u.EA.type & ZEND_PARSED_REFERENCE_VARIABLE) {
24.           //以引用方式獲取值
25.         assign_by_ref = 1;
26.         if (!(opline-1)->extended_value) {
27.                //根據FE_FETCH的上一條Opline也就是獲取數組的擴展值來判斷數組是不是匿名數組
28.             zend_error(E_COMPILE_ERROR, "Cannot create references to elements of a temporary array expression");
29.         }
30.  
31.         opline->extended_value |= ZEND_FE_FETCH_BYREF; //指明按引用取
32.         CG(active_op_array)->opcodes[foreach_token->u.opline_num].extended_value |= ZEND_FE_RESET_REFERENCE; //重置原數組
33.     } else {
34.         zend_op *foreach_copy;
35.         zend_op *fetch = &CG(active_op_array)->opcodes[foreach_token->u.opline_num];
36.         zend_op *end = &CG(active_op_array)->opcodes[open_brackets_token->u.opline_num];
37.  
38.         /* Change "write context" into "read context" */
39.         fetch->extended_value = 0; /* reset ZEND_FE_RESET_VARIABLE */
40.         while (fetch != end) {
41.             --fetch;
42.             if (fetch->opcode == ZEND_FETCH_DIM_W && fetch->op2.op_type == IS_UNUSED) {
43.                 zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
44.             }
45.             fetch->opcode -= 3; /* FETCH_W -> FETCH_R */
46.         }
47.  
48.         /* prevent double SWITCH_FREE */
49.         zend_stack_top(&CG(foreach_copy_stack), (void **) &foreach_copy);
50.         foreach_copy->op1.op_type = IS_UNUSED;
51.     }
52.  
53.     value_node = opline->result;
54.  
55.     if (assign_by_ref) {
56.         zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC); //獲取值（引用）
57.         zend_do_assign_ref(NULL, value, &value_node TSRMLS_CC);//指明value node的type是IS_VAR
58.     } else {
59.         zend_do_assign(&dummy, value, &value_node TSRMLS_CC); //獲取copy值
60.         zend_do_free(&dummy TSRMLS_CC);
61.     }
62.  
63.     if (key->op_type != IS_UNUSED) {
64.         znode key_node;
65.  
66.         opline = &CG(active_op_array)->opcodes[as_token->u.opline_num+1];
67.         opline->result.op_type = IS_TMP_VAR;
68.         opline->result.u.EA.type = 0;
69.         opline->result.u.opline_num = get_temporary_variable(CG(active_op_array));
70.         key_node = opline->result;
71.  
72.         zend_do_assign(&dummy, key, &key_node TSRMLS_CC);
73.         zend_do_free(&dummy TSRMLS_CC);
74.     }
75.  
76.     do_begin_loop(TSRMLS_C);
77.     INC_BPC(CG(active_op_array));
78. }

1. void zend_do_foreach_end(znode *foreach_token, znode *as_token TSRMLS_DC)
2. {
3.     zend_op *container_ptr;
4.     zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); //生成JMP opcode
5.  
6.     opline->opcode = ZEND_JMP;
7.     opline->op1.u.opline_num = as_token->u.opline_num; //設置JMP到FE_FETCH opline行
8.     SET_UNUSED(opline->op1);
9.     SET_UNUSED(opline->op2);
10.  
11.     CG(active_op_array)->opcodes[foreach_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array)); //設置跳出循環的opline行
12.     CG(active_op_array)->opcodes[as_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array)); //同上
13.  
14.     do_end_loop(as_token->u.opline_num, 1 TSRMLS_CC); //爲循環嵌套而設置
15.  
16.     zend_stack_top(&CG(foreach_copy_stack), (void **) &container_ptr);
17.     generate_free_foreach_copy(container_ptr TSRMLS_CC);
18.     zend_stack_del_top(&CG(foreach_copy_stack));
19.  
20.     DEC_BPC(CG(active_op_array)); //爲PHP interactive模式而設置
21. }

 

 

分享到：2

 

 深刻理解PHP之數組(遍歷順序) 

常常會有人問我, PHP的數組, 若是用foreach來訪問, 遍歷的順序是固定的麼? 以什麼順序遍歷呢?

好比:

1. <?php
2. $arr['laruence'] = 'huixinchen';
3. $arr['yahoo'] = 2007;
4. $arr['baidu'] = 2008;
5. foreach ($arr as $key => $val) {
6. //結果是什麼?
7. }

又好比:

1. <?php
2. $arr[2] = 'huixinchen';
3. $arr[1] = 2007;
4. $arr[0] = 2008;
5. foreach ($arr as $key => $val) {
6. //如今結果又是什麼?
7. }

要徹底瞭解清楚這個問題, 我想首先應該要你們瞭解PHP數組的內部實現結構………

PHP的數組

在PHP中, 數組是用一種HASH結構(HashTable)來實現的, PHP使用了一些機制, 使得能夠在O(1)的時間複雜度下實現數組的增刪, 並同時支持線性遍歷和隨機訪問.

以前的文章中也討論過, PHP的HASH算法, 基於此, 咱們作進一步的延伸.

認識HashTable以前, 首先讓咱們看看HashTable的結構定義, 我加了註釋方便你們理解:

1. typedef struct _hashtable {
2. uint nTableSize; /* 散列表大小, Hash值的區間 */
3. uint nTableMask; /* 等於nTableSize -1, 用於快速定位 */
4. uint nNumOfElements; /* HashTable中實際元素的個數 */
5. ulong nNextFreeElement; /* 下個空閒可用位置的數字索引 */
6. Bucket *pInternalPointer; /* 內部位置指針, 會被reset, current這些遍歷函數使用 */
7. Bucket *pListHead; /* 頭元素, 用於線性遍歷 */
8. Bucket *pListTail; /* 尾元素, 用於線性遍歷 */
9. Bucket **arBuckets; /* 實際的存儲容器 */
10. dtor_func_t pDestructor;/* 元素的析構函數(指針) */
11. zend_bool persistent;
12. unsigned char nApplyCount; /* 循環遍歷保護 */
13. zend_bool bApplyProtection;
14. #if ZEND_DEBUG
15. int inconsistent;
16. #endif
17. } HashTable;

關於nApplyCount的意義, 咱們能夠經過一個例子來了解:

1. <?php
2.     $arr = array(1,2,3,4,5,);
3.     $arr[] = &$arr;
4.  
5.     var_export($arr); //Fatal error: Nesting level too deep - recursive dependency?

這個字段就是爲了防治循環引用致使的無限循環而設立的.

查看上面的結構, 能夠看出, 對於HashTable, 關鍵元素就是arBuckets了, 這個是實際存儲的容器, 讓咱們來看看它的結構定義:

1. typedef struct bucket {
2. ulong h; /* 數字索引/hash值 */
3. uint nKeyLength; /* 字符索引的長度 */
4. void *pData; /* 數據 */
5. void *pDataPtr; /* 數據指針 */
6. struct bucket *pListNext; /* 下一個元素, 用於線性遍歷 */
7. struct bucket *pListLast; /* 上一個元素, 用於線性遍歷 */
8. struct bucket *pNext; /* 處於同一個拉鍊中的下一個元素 */
9. struct bucket *pLast; /* 處於同一拉鍊中的上一個元素 */
10. char arKey[1]; /* 節省內存,方便初始化的技巧 */
11. } Bucket;

咱們注意到, 最後一個元素, 這個是flexible array技巧, 能夠節省內存,和方便初始化的一種作法, 有興趣的朋友能夠google flexible array.

h是元素的Hash值,對於數字索引的元素,h爲直接索引值(經過nKeyLength=0來表示是數字索引).而對於字符串索引來講, 索引值保存在arKey中, 索引的長度保存在nKeyLength中.

在Bucket中，實際的數據是保存在pData指針指向的內存塊中，一般這個內存塊是系統另外分配的。但有一種狀況例外，就是當Bucket保存 的數據是一個指針時，HashTable將不會另外請求系統分配空間來保存這個指針，而是直接將該指針保存到pDataPtr中，而後再將pData指向本結構成員的地址。這樣能夠提升效率，減小內存碎片。由此咱們能夠看到PHP HashTable設計的精妙之處。若是Bucket中的數據不是一個指針，pDataPtr爲NULL(本段來自Altair<eniac2008@hotmail.com>的」Zend HashTable詳解」)

結合上面的HashTable結構, 咱們來講明下HashTable的總結構圖:

HashTable結構示意圖

 

HashTable的pListhHead指向線性列表形式下的第一個元素, 上圖中是元素1, pListTail指向的是最後一個元素0, 而對於每個元素pListNext就是紅色線條畫出的線性結構的下一個元素, 而pListLast是上一個元素.

pInternalPointer指向當前的內部指針的位置, 在對數組進行順序遍歷的時候, 這個指針指明瞭當前的元素.

當在線性(順序)遍歷的時候, 就會從pListHead開始, 順着Bucket中的pListNext/pListLast, 根據移動pInternalPointer, 來實現對全部元素的線性遍歷.

好比, 對於foreach, 若是咱們查看它生成的opcode序列, 咱們能夠發現, 在foreach以前, 會首先有個FE_RESET來重置數組的內部指針, 也就是pInternalPointer(關於foreach能夠參看深刻理解PHP原理之foreach), 而後經過每次FE_FETCH來遞增pInternalPointer,從而實現順序遍歷.

相似的, 當咱們使用, each/next系列函數來遍歷的時候, 也是經過移動數組的內部指針而實現了順序遍歷, 這裏有一個問題, 好比:

1. <?php
2. $arr = array(1,2,3,4,5);
3. foreach ($arr as $v) {
4. //能夠獲取
5. }
6.  
7. while (list($key, $v) = each($arr)) {
8. //獲取不到
9. }
10. ?>

瞭解到我剛纔介紹的知識, 那麼這個問題也就很明朗了, 由於foreach會自動reset, 而while這塊不會reset, 因此在foreach結束之後, pInternalPointer指向數組最末端, while語句塊固然訪問不到了, 解決的辦法就是在each以前, 先reset數組的內部指針.

而在隨機訪問的時候, 就會經過hash值肯定在hash數組中的頭指針位置, 而後經過pNext/pLast來找到特色元素.

增長元素的時候, 元素會插在相同Hash元素鏈的頭部和線性列表的尾部. 也就是說, 元素在線性遍歷的時候是根據插入的前後順序來遍歷的, 這個特殊的設計使得在PHP中,當使用數字索引時, 元素的前後順序是由添加的順序決定的,而不是索引順序.

也就是說, PHP中遍歷數組的順序, 是和元素的添加前後相關的, 那麼, 如今咱們就很清楚的知道, 文章開頭的問題的輸出是:

1. huixinchen
2. 2007
3. 2008

因此, 若是你想在數字索引的數組中按照索引大小遍歷, 那麼你就應該使用for, 而不是foreach

1. for($i=0,$l=count($arr); $i<$l; $i++) {
2.  //這個時候,不能認爲是順序遍歷(線性遍歷)
3. }