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. if (variable) {
8. //是否是匿名数组
9. if (zend_is_function_or_method_call(array)) {
10. //是否是函数返回值
11. is_variable = 0;
12. } else {
13. is_variable = 1;
14. }
15. /* 使用括号记录FE_RESET的opline行数 */
16. open_brackets_token->u.opline_num = get_next_op_number(CG(active_op_array));
17. zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); //获取数组/对象和zend_do_begin_variable_parse对应
18. if (CG(active_op_array)->last > 0 &&
19. CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode == ZEND_FETCH_OBJ_W) {
20. /* Only lock the container if we are fetching from a real container and not $this */
21. if (CG(active_op_array)->opcodes[CG(active_op_array)->last-1].op1.op_type == IS_VAR) {
22. CG(active_op_array)->opcodes[CG(active_op_array)->last-1].extended_value |= ZEND_FETCH_ADD_LOCK;
23. push_container = 1;
24. }
25. }
26. } else {
27. is_variable = 0;
28. open_brackets_token->u.opline_num = get_next_op_number(CG(active_op_array));
29. }
30. foreach_token->u.opline_num = get_next_op_number(CG(active_op_array)); //记录数组Reset Opline number
31. opline = get_next_op(CG(active_op_array) TSRMLS_CC); //生成Reset数组Opcode
32. opline->opcode = ZEND_FE_RESET;
33. opline->result.op_type = IS_VAR;
34. opline->result.u.var = get_temporary_variable(CG(active_op_array));
35. opline->op1 = *array;
36. SET_UNUSED(opline->op2);
37. opline->extended_value = is_variable ? ZEND_FE_RESET_VARIABLE : 0;
38. dummy_opline.result = opline->result;
39. if (push_container) {
40. dummy_opline.op1 = CG(active_op_array)->opcodes[CG(active_op_array)->last-2].op1;
41. } else {
42. znode tmp;
43. tmp.op_type = IS_UNUSED;
44. dummy_opline.op1 = tmp;
45. }
46. zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op));
47. as_token->u.opline_num = get_next_op_number(CG(active_op_array)); //记录循环起始点
48. opline = get_next_op(CG(active_op_array) TSRMLS_CC);
49. opline->opcode = ZEND_FE_FETCH;
50. opline->result.op_type = IS_VAR;
51. opline->result.u.var = get_temporary_variable(CG(active_op_array));
52. opline->op1 = dummy_opline.result; //被操作数组
53. opline->extended_value = 0;
54. SET_UNUSED(opline->op2);
55. opline = get_next_op(CG(active_op_array) TSRMLS_CC);
56. opline->opcode = ZEND_OP_DATA; //当使用key的时候附属操作数,当foreach中不包含key时忽略
57. SET_UNUSED(opline->op1);
58. SET_UNUSED(opline->op2);
59. SET_UNUSED(opline->result);
60. }

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

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. opline->opcode = ZEND_JMP;
6. opline->op1.u.opline_num = as_token->u.opline_num; //设置JMP到FE_FETCH opline行
7. SET_UNUSED(opline->op1);
8. SET_UNUSED(opline->op2);
9. CG(active_op_array)->opcodes[foreach_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array)); //设置跳出循环的opline行
10. CG(active_op_array)->opcodes[as_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array)); //同上
11. do_end_loop(as_token->u.opline_num, 1 TSRMLS_CC); //为循环嵌套而设置
12. zend_stack_top(&CG(foreach_copy_stack), (void **) &container_ptr);
13. generate_free_foreach_copy(container_ptr TSRMLS_CC);
14. zend_stack_del_top(&CG(foreach_copy_stack));
15. DEC_BPC(CG(active_op_array)); //为PHP interactive模式而设置
16. }

分享到：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. 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. while (list($key, $v) = each($arr)) {
7. //获取不到
8. }
9. ?>

了解到我刚才介绍的知识, 那么这个问题也就很明朗了, 因为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. }