前言：
php4中引入了foreach结构，这是一种遍历数组的简单方式。相比传统的for循环，foreach能够更加便捷的获取键值对。在php5之前，foreach仅能用于数组；php5之后，利用foreach还能遍历对象（详见：遍历对象）。本文中仅讨论遍历数组的情况。
foreach虽然简单，不过它可能会出现一些意外的行为，特别是代码涉及引用的情况下。
下面列举了几种case，有助于我们进一步认清foreach的本质。
问题1：
$arr = array(1,2,3);
foreach($arr as $k => &$v) {
$v = $v * 2;
}
// now $arr is array(2, 4, 6)
foreach($arr as $k => $v) {
echo "$k", " => ", "$v";
}
先从简单的开始，如果我们尝试运行上述代码，就会发现最后输出为0=>2 1=>4 2=>4 。
为何不是0=>2 1=>4 2=>6 ？
其实，我们可以认为 foreach($arr as $k => $v) 结构隐含了如下操作，分别将数组当前的'键'和当前的'值'赋给变量$k和$v。具体展开形如：
foreach($arr as $k => $v){
//在用户代码执行之前隐含了2个赋值操作
$v = currentval();
$k = currentkey();
//继续运行用户代码
……
}
根据上述理论，现在我们重新来分析下第一个foreach：
第1遍循环，由于$v是一个引用，因此$v = &$arr[0]，$v=$v*2相当于$arr[0]*2，因此$arr变成2,2,3
第2遍循环，$v = &$arr[1]，$arr变成2,4,3
第3遍循环，$v = &$arr[2]，$arr变成2,4,6
随后代码进入了第二个foreach：
第1遍循环，隐含操作$v=$arr[0]被触发，由于此时$v仍然是$arr[2]的引用，即相当于$arr[2]=$arr[0]，$arr变成2,4,2
第2遍循环，$v=$arr[1]，即$arr[2]=$arr[1]，$arr变成2,4,4
第3遍循环，$v=$arr[2]，即$arr[2]=$arr[2]，$arr变成2,4,4
ok，分析完毕。
如何解决类似问题呢？php手册上有一段提醒：
warning : 数组最后一个元素的 $value 引用在 foreach 循环之后仍会保留。建议使用unset()来将其销毁。
$arr = array(1,2,3);
foreach($arr as $k => &$v) {
$v = $v * 2;
}
unset($v);
foreach($arr as $k => $v) {
echo "$k", " => ", "$v";
}
// 输出 0=>2 1=>4 2=>6
从这个问题中我们可以看出，引用很有可能会伴随副作用。如果不希望无意识的修改导致数组内容变更，最好及时unset掉这些引用。
问题2：
$arr = array('a','b','c');
foreach($arr as $k => $v) {
echo key($arr), "=>", current($arr);
}
// 打印 1=>b 1=>b 1=>b
这个问题更加诡异。按照手册的说法，key和current分别是取数组中当前元素的的键值。
那为何key($arr)一直是1，current($arr)一直是b呢?
先用vld查看编译之后的opcode:
我们从第3行的assign指令看起，它代表将array('a','b','c')赋值给$arr。
由于$arr为cv，array('a','b','c')为tmp，因此assign指令找到实际执行的函数为zend_assign_spec_cv_tmp_handler。这里需要特别指出，cv是php5.1之后才增加的一种变量cache，它采用数组的形式来保存zval**，被cache住的变量再次使用时无需去查找active符号表，而是直接去cv数组中获取，由于数组访问速度远超hash表，因而可以提高效率。
static int zend_fastcall zend_assign_spec_cv_tmp_handler(zend_opcode_handler_args)
{
zend_op *opline = ex(opline);
zend_free_op free_op2;
zval *value = _get_zval_ptr_tmp(&opline->op2, ex(ts), &free_op2 tsrmls_cc);
// cv数组中创建出$arr**指针
zval **variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, ex(ts), bp_var_w tsrmls_cc);
if (is_cv == is_var && !variable_ptr_ptr) {
……
}
else {
// 将array赋值给$arr
value = zend_assign_to_variable(variable_ptr_ptr, value, 1 tsrmls_cc);
if (!return_value_unused(&opline->result)) {
ai_set_ptr(ex_t(opline->result.u.var).var, value);
pzval_lock(value);
}
}
zend_vm_next_opcode();
}
assign指令完成之后，cv数组中被加入zval**指针，指针指向实际的array，这表示$arr已经被cv缓存了起来。
接下来执行数组的循环操作，我们来看fe_reset指令，它对应的执行函数为
zend_fe_reset_spec_cv_handler：
static int zend_fastcall zend_fe_reset_spec_cv_handler(zend_opcode_handler_args)
{
……
if (……) {
……
} else {
// 通过cv数组获取指向array的指针
array_ptr = _get_zval_ptr_cv(&opline->op1, ex(ts), bp_var_r tsrmls_cc);
……
}
……
// 将指向array的指针保存到zend_execute_data->ts中(ts用于存放代码执行期的temp_variable)
ai_set_ptr(ex_t(opline->result.u.var).var, array_ptr);
pzval_lock(array_ptr);
if (iter) {
……
} else if ((fe_ht = hash_of(array_ptr)) != null) {
// 重置数组内部指针
zend_hash_internal_pointer_reset(fe_ht);
if (ce) {
……
}
is_empty = zend_hash_has_more_elements(fe_ht) != success;
// 设置ex_t(opline->result.u.var).fe.fe_pos用于保存数组内部指针
zend_hash_get_pointer(fe_ht, &ex_t(opline->result.u.var).fe.fe_pos);
} else {
……
}
……
}
这里主要将2个重要的指针存入了zend_execute_data->ts中:
•ex_t(opline->result.u.var).var ---- 指向array的指针
•ex_t(opline->result.u.var).fe.fe_pos ---- 指向array内部元素的指针
fe_reset指令执行完毕之后，内存中实际情况如下：
接下来我们继续查看fe_fetch，它对应的执行函数为zend_fe_fetch_spec_var_handler：
static int zend_fastcall zend_fe_fetch_spec_var_handler(zend_opcode_handler_args)
{
zend_op *opline = ex(opline);
// 注意指针是从ex_t(opline->op1.u.var).var.ptr获取的
zval *array = ex_t(opline->op1.u.var).var.ptr;
……
switch (zend_iterator_unwrap(array, &iter tsrmls_cc)) {
default:
case zend_iter_invalid:
……
case zend_iter_plain_object: {
……
}
case zend_iter_plain_array:
fe_ht = hash_of(array);
// 特别注意：
// fe_reset指令中将数组内部元素的指针保存在ex_t(opline->op1.u.var).fe.fe_pos
// 此处获取该指针
zend_hash_set_pointer(fe_ht, &ex_t(opline->op1.u.var).fe.fe_pos);
// 获取元素的值
if (zend_hash_get_current_data(fe_ht, (void **) &value)==failure) {
zend_vm_jmp(ex(op_array)->opcodes+opline->op2.u.opline_num);
}
if (use_key) {
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 1, null);
}
// 数组内部指针移动到下一个元素
zend_hash_move_forward(fe_ht);
// 移动之后的指针保存到ex_t(opline->op1.u.var).fe.fe_pos
zend_hash_get_pointer(fe_ht, &ex_t(opline->op1.u.var).fe.fe_pos);
break;
case zend_iter_object:
……
}
……
}
根据fe_fetch的实现，我们大致上明白了foreach($arr as $k => $v)所做的事情。它会根据zend_execute_data->ts的指针去获取数组元素，在获取成功之后，将该指针移动到下一个位置再重新保存。
简单来说，由于第一遍循环中fe_fetch中已经将数组的内部指针移动到了第二个元素，所以在foreach内部调用key($arr)和current($arr)时，实际上获取的便是1和'b'。
那为何会输出3遍1=>b呢？
我们继续看第9行和第13行的send_ref指令，它表示将$arr参数压栈。紧接着一般会使用do_fcall指令去调用key和current函数。php并非被编译成本地机器码，因此php采用这样的opcode指令去模拟实际cpu和内存的工作方式。
查阅php源码中的send_ref：
static int zend_fastcall zend_send_ref_spec_cv_handler(zend_opcode_handler_args)
{
……
// 从cv中获取$arr指针的指针
varptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, ex(ts), bp_var_w tsrmls_cc);
……
// 变量分离，此处重新copy了一份array专门用于key函数
separate_zval_to_make_is_ref(varptr_ptr);
varptr = *varptr_ptr;
z_addref_p(varptr);
// 压栈
zend_vm_stack_push(varptr tsrmls_cc);
zend_vm_next_opcode();
}
上述代码中的separate_zval_to_make_is_ref是一个宏：
#define separate_zval_to_make_is_ref(ppzv) \
if (!pzval_is_ref(*ppzv)) { \
separate_zval(ppzv); \
z_set_isref_pp((ppzv)); \
}
separate_zval_to_make_is_ref的主要作用为，如果变量不是一个引用，则在内存中copy出一份新的。本例中它将array('a','b','c')复制了一份。因此变量分离之后的内存为：
注意，变量分离完成之后，cv数组中的指针指向了新copy出来的数据，而通过zend_execute_data->ts中的指针则依然可以获取旧的数据。
接下来的循环就不一一赘述了，结合上图来说：
•foreach结构使用的是下方蓝色的array，会依次遍历a，b，c
•key、current使用的是上方黄色的array，它的内部指针永远指向b
至此我们明白了为何key和current一直返回array的第二个元素，由于没有外部代码作用于copy出来的array，它的内部指针便永远不会移动。
问题3：
$arr = array('a','b','c');
foreach($arr as $k => &$v) {
echo key($arr), '=>', current($arr);
}// 打印 1=>b 2=>c =>
本题与问题2仅有一点区别：本题中的foreach使用了引用。用vld查看本题，发现与问题2代码编译出来的opcode一样。因此我们采用问题2的跟踪方法，逐步查看opcode对应的实现。
首先foreach会调用fe_reset:
static int zend_fastcall zend_fe_reset_spec_cv_handler(zend_opcode_handler_args)
{
……
if (opline->extended_value & zend_fe_reset_variable) {
// 从cv中获取变量
array_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, ex(ts), bp_var_r tsrmls_cc);
if (array_ptr_ptr == null || array_ptr_ptr == &eg(uninitialized_zval_ptr)) {
……
}
else if (z_type_pp(array_ptr_ptr) == is_object) {
……
}
else {
// 针对遍历array的情况
if (z_type_pp(array_ptr_ptr) == is_array) {
separate_zval_if_not_ref(array_ptr_ptr);
if (opline->extended_value & zend_fe_fetch_byref) {
// 将保存array的zval设置为is_ref
z_set_isref_pp(array_ptr_ptr);
}
}
array_ptr = *array_ptr_ptr;
z_addref_p(array_ptr);
}
} else {
……
}
……
}
问题2中已经分析了一部分fe_reset的实现。这里需要特别注意，本例foreach获取值采用了引用，因此在执行的时候fe_reset中会进入与上题不同的另一个分支。
最终，fe_reset会将array的is_ref设置为true，此时内存中只有一份array的数据。
接下来分析send_ref：
static int zend_fastcall zend_send_ref_spec_cv_handler(zend_opcode_handler_args)
{
……
// 从cv中获取$arr指针的指针
varptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, ex(ts), bp_var_w tsrmls_cc);
……
// 变量分离，由于此时cv中的变量本身就是一个引用，此处不会copy一份新的array
separate_zval_to_make_is_ref(varptr_ptr);
varptr = *varptr_ptr;
z_addref_p(varptr);
// 压栈
zend_vm_stack_push(varptr tsrmls_cc);
zend_vm_next_opcode();
}
宏separate_zval_to_make_is_ref仅仅分离is_ref=false的变量。由于之前array已经被设置了is_ref=true，因此它不会被拷贝一份副本。换句话说，此时内存中依然只有一份array数据。
上图解释了前2次循环为何会输出1=>b 2=>c。在第3次循环fe_fetch的时候，将指针继续向前移动。
zend_api int zend_hash_move_forward_ex(hashtable *ht, hashposition *pos)
{
hashposition *current = pos ? pos : &ht->pinternalpointer;
is_consistent(ht);
if (*current) {
*current = (*current)->plistnext;
return success;
} else
return failure;
}
由于此时内部指针已经指向了数组的最后一个元素，因此再向前移动会指向null。将内部指针指向null之后，我们再对数组调用key和current，则分别会返回null和false，表示调用失败，此时是echo不出字符的。
问题4：
$arr = array(1, 2, 3);
$tmp = $arr;
foreach($tmp as $k => &$v){
$v *= 2;
}
var_dump($arr, $tmp); // 打印什么？
该题与foreach关系不大，不过既然涉及到了foreach，就一起拿来讨论吧:)
代码里首先创建了数组$arr，随后将该数组赋给了$tmp，在接下来的foreach循环中，对$v进行修改会作用于数组$tmp上，但是却并不作用到$arr。
为什么呢?
这是由于在php中，赋值运算是将一个变量的值拷贝到另一个变量中，因此修改其中一个，并不会影响到另一个。
题外话：这并不适用于object类型，从php5起，对象的便总是默认通过引用进行赋值，举例来说：
class a{
public $foo = 1;
}
$a1 = $a2 = new a;
$a1->foo=100;
echo $a2->foo; // 输出100，$a1与$a2其实为同一个对象的引用
回到题目中的代码，现在我们可以确定$tmp=$arr其实是值拷贝，整个$arr数组会被再复制一份给$tmp。理论上讲，赋值语句执行完毕之后，内存中会有2份一样的数组。
也许有同学会疑问，如果数组很大，岂不是这种操作会很慢？
幸好php有更聪明的处理办法。实际上，当$tmp=$arr执行之后，内存中依然只有一份array。查看php源码中的zend_assign_to_variable实现（摘自php5.3.26）：
static inline zval* zend_assign_to_variable(zval **variable_ptr_ptr, zval *value, int is_tmp_var tsrmls_dc)
{
zval *variable_ptr = *variable_ptr_ptr;
zval garbage;
……
// 左值为object类型
if (z_type_p(variable_ptr) == is_object && z_obj_handler_p(variable_ptr, set)) {
……
}
// 左值为引用的情况
if (pzval_is_ref(variable_ptr)) {
……
} else {
// 左值refcount__gc=1的情况
if (z_delref_p(variable_ptr)==0) {
……
} else {
gc_zval_check_possible_root(*variable_ptr_ptr);
// 非临时变量
if (!is_tmp_var) {
if (pzval_is_ref(value) && z_refcount_p(value) > 0) {
alloc_zval(variable_ptr);
*variable_ptr_ptr = variable_ptr;
*variable_ptr = *value;
z_set_refcount_p(variable_ptr, 1);
zval_copy_ctor(variable_ptr);
} else {
// $tmp=$arr会运行到这里，
// value为指向$arr里实际array数据的指针，variable_ptr_ptr为$tmp里指向数据指针的指针
// 仅仅是复制指针，并没有真正拷贝实际的数组
*variable_ptr_ptr = value;
// value的refcount__gc值+1，本例中refcount__gc为1，z_addref_p之后为2
z_addref_p(value);
}
} else {
……
}
}
z_unset_isref_pp(variable_ptr_ptr);
}
return *variable_ptr_ptr;
}
可见$tmp = $arr的本质就是将array的指针进行复制，然后将array的refcount自动加1.用图表达出此时的内存，依然只有一份array数组：
既然只有一份array，那foreach循环中修改$tmp的时候，为何$arr没有跟着改变？
继续看php源码中的zend_fe_reset_spec_cv_handler函数，这是一个opcode handler，它对应的opcode为fe_reset。该函数负责在foreach开始之前，将数组的内部指针指向其第一个元素。
static int zend_fastcall zend_fe_reset_spec_cv_handler(zend_opcode_handler_args)
{
zend_op *opline = ex(opline);
zval *array_ptr, **array_ptr_ptr;
hashtable *fe_ht;
zend_object_iterator *iter = null;
zend_class_entry *ce = null;
zend_bool is_empty = 0;
// 对变量进行fe_reset
if (opline->extended_value & zend_fe_reset_variable) {
array_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, ex(ts), bp_var_r tsrmls_cc);
if (array_ptr_ptr == null || array_ptr_ptr == &eg(uninitialized_zval_ptr)) {
……
}
// foreach一个object
else if (z_type_pp(array_ptr_ptr) == is_object) {
……
}
else {
// 本例会进入该分支
if (z_type_pp(array_ptr_ptr) == is_array) {
// 注意此处的separate_zval_if_not_ref
// 它会重新复制一个数组出来
// 真正分离$tmp和$arr，变成了内存中的2个数组
separate_zval_if_not_ref(array_ptr_ptr);
if (opline->extended_value & zend_fe_fetch_byref) {
z_set_isref_pp(array_ptr_ptr);
}
}
array_ptr = *array_ptr_ptr;
z_addref_p(array_ptr);
}
} else {
……
}
// 重置数组内部指针
……
}
从代码中可以看出，真正执行变量分离并不是在赋值语句执行的时候，而是推迟到了使用变量的时候，这也是copy on write机制在php中的实现。
fe_reset之后，内存的变化如下：
上图解释了为何foreach并不会对原来的$arr产生影响。至于ref_count以及is_ref的变化情况，感兴趣的同学可以详细阅读zend_fe_reset_spec_cv_handler和zend_switch_free_spec_var_handler的具体实现（均位于php-src/zend/zend_vm_execute.h中），本文不做详细剖析:)
如对本文有疑问，
点击进行留言回复！！
我要评论
网友评论