请考虑以下 PHP 代码：
//Method 1
$array = array(1,2,3,4,5);
foreach($array as $i=>$number){
$number++;
$array[$i] = $number;
}
print_r($array);
//Method 2
$array = array(1,2,3,4,5);
foreach($array as &$number){
$number++;
}
print_r($array);
这两种方法都能完成相同的任务，一种是通过分配引用，另一种是基于键重新分配。我希望在我的工作中使用良好的编程技术，不知道哪种方法更好？还是说这只是那种无论怎样都没关系的事情之一？
尽管如此，就像Orangepill展示的那样，引用方法提供了更好的性能。在这种情况下，权衡是性能与代码之间易于出错、易于阅读/维护。通常认为，更安全、更可靠、更易于维护的代码更好：
'调试比首次编写代码困难两倍。因此，如果您尽可能聪明地编写代码，则从定义上来说，您不够聪明来调试它。' —— Brian Kernighan
我想这意味着第一种方法必须被认为是最佳实践。但这并不意味着第二种方法应该始终避免，因此下面列出的是在foreach循环中使用引用时需要考虑的缺点、陷阱和怪癖：
作用域：
首先，PHP并不像C(++), C#, Java, Perl或（运气好的话）ECMAScript6那样真正具有块作用域...这意味着$value变量在循环结束后不会被取消设置。当通过引用循环时，这意味着对于你正在迭代的任何对象/数组的最后一个值的引用正在浮动。应该想到的一个短语是“等待发生意外”。
考虑以下代码中$value和随后的$array会发生什么：
$array = range(1,10);
foreach($array as &$value)
{
$value++;
}
echo json_encode($array);
$value++;
echo json_encode($array);
$value = 'Some random value';
echo json_encode($array);
[2,3,4,5,6,7,8,9,10,11]
[2,3,4,5,6,7,8,9,10,12]
[2,3,4,5,6,7,8,9,10,"Some random value"]
$value变量（该变量引用数组中的最后一个元素），实际上是在操作数组本身。这会导致容易出错的代码和难以调试。相反，可以这样做：$array = range(1,10);
$array[] = 'foobar';
foreach($array as $k => $v)
{
$array[$k]++;//increments foobar, to foobas!
if ($array[$k] === ($v +1))//$v + 1 yields 1 if $v === 'foobar'
{//so 'foobas' === 1 => false
$array[$k] = $v;//restore initial value: foobar
}
}
可维护性/傻瓜式操作：
当然，你可能会说悬空引用是容易修复的问题，而且你是正确的：
foreach($array as &$value)
{
$value++;
}
unset($value);
但是，当你写了100个带有引用的循环后，你真的相信你没有忘记取消一个引用吗？当然不是！这么不常见的情况下，去 unset 在循环中使用过的变量（我们假设垃圾回收会为我们处理），所以大多数时候，你都不会费心。但是当涉及到引用时，这是一种令人沮丧的来源，神秘的错误报告或者 旅行值，在其中你使用复杂的嵌套循环，可能还带有多个引用……恐怖，恐怖。
此外，随着时间的推移，谁能保证下一个工作在你代码上的人不会忘记 unset 呢？谁知道他甚至可能不知道引用，或者看到你众多的 unset 调用，认为它们是多余的，是你过于紧张的标志，并将它们全部删除。仅靠注释是不够的：它们需要被阅读，每个与你的代码一起工作的人都应该接受彻底的指导，也许让他们阅读一篇关于此主题的完整文章。链接文章中列举的示例很糟糕，但我见过更糟糕的：
foreach($nestedArr as &$array)
{
if (count($array)%2 === 0)
{
foreach($array as &$value)
{//pointless, but you get the idea...
$value = array($value, 'Part of even-length array');
}
//$value now references the last index of $array
}
else
{
$value = array_pop($array);//assigns new value to var that might be a reference!
$value = is_numeric($value) ? $value/2 : null;
array_push($array, $value);//congrats, X-references ==> traveling value!
}
}
这是一个简单的旅行价值问题示例。顺便说一下，我并没有编造这个代码，我曾经遇到过这样的代码……老实说，除了发现错误和理解代码（参考已经增加了难度），在这个例子中仍然很明显，主要是因为它只有15行长度，即使使用了宽敞的Allman代码风格…… 现在想象一下这个基本结构被用于实际上执行稍微复杂和有意义的代码。祝你调试愉快。
副作用：
通常人们说函数不应该具有副作用，因为副作用被（正确地）认为是代码异味。虽然foreach是语言构造，而不是函数，在您的示例中，应该采用相同的思维方式。当使用过多的引用时，你就会变得过于聪明，可能会发现自己必须在循环中一步一步查找哪个变量引用了哪个变量以及何时引用了它。
第一种方法没有这个问题：你有钥匙，所以你知道自己在数组中的位置。更重要的是，使用第一种方法，你可以对值进行任意数量的操作，而不改变数组中的原始值（没有副作用）：
function recursiveFunc($n, $max = 10)
{
if (--$max)
{
return $n === 1 ? 10-$max : recursiveFunc($n%2 ? ($n*3)+1 : $n/2, $max);
}
return null;
}
$array = range(10,20);
foreach($array as $k => $v)
{
$v = recursiveFunc($v);//reassigning $v here
if ($v !== null)
{
$array[$k] = $v;//only now, will the actual array change
}
}
echo json_encode($array);
[7,11,12,13,14,15,5,17,18,19,8]
正如您所看到的，第一个、第七个和第十个元素已被更改，其他元素没有被更改。如果我们使用引用循环重写此代码，则循环看起来要小得多，但输出将不同（我们有副作用）：
$array = range(10,20);
foreach($array as &$v)
{
$v = recursiveFunc($v);//Changes the original array...
//granted, if your version permits it, you'd probably do:
$v = recursiveFunc($v) ?: $v;
}
echo json_encode($array);
//[7,null,null,null,null,null,5,null,null,null,8]
$v的初始值，但这只是徒劳无功（增加复杂性却不能修复本该不应出现的问题）。foreach($array as &$v)
{
$temp = recursiveFunc($v);//creating copy here, anyway
$v = $temp ? $temp : $v;//assignment doesn't require the lookup, though
}
//or:
foreach($array as &$v)
{
$v = recursiveFunc($v) ? recursiveFunc($v) : $v;//2 calls === twice the overhead!
}
//or
$base = reset($array);//get the base value
foreach($array as $k => &$v)
{//silly combine both methods to fix what needn't be a problem to begin with
$v = recursiveFunc($v);
if ($v === 0)
{
$v = $base + $k;
}
}
unset()的重要说明，请注意 + 符号。 - Jason McCreary$array = range(1, 1000000);
$start = microtime(true);
foreach($array as $k => $v){
$array[$k] = $v+1;
}
echo "Method 1: ".((microtime(true)-$start));
echo "\n";
$start = microtime(true);
foreach($array as $k => &$v){
$v+=1;
}
echo "Method 2: ".((microtime(true)-$start));
Method 1: 0.72429609298706
Method 2: 0.22671484947205
Method 1: 3.504753112793E-5
Method 2: 1.2874603271484E-5
使用字符串键时，性能差异更为明显。所以运行中。
$array = array();
for($x = 0; $x<1000000; $x++){
$array["num".$x] = $x+1;
}
$start = microtime(true);
foreach($array as $k => $v){
$array[$k] = $v+1;
}
echo "Method 1: ".((microtime(true)-$start));
echo "\n";
$start = microtime(true);
foreach($array as $k => &$v){
$v+=1;
}
echo "Method 2: ".((microtime(true)-$start));
Method 1: 0.90371179580688
Method 2: 0.2799870967865
unset($v);并且应该对性能增益与可读性的损失进行衡量。有一些轻微的性能差异，但它们不会产生任何重大影响。
我会选择第一个选项，原因有两个：
It's more readable. This is a bit of a personal preference, but at first glance, it's not immediately obvious to me that $number++ is updating the array. By explicitly using something like $array[$i]++, it's much clearer, and less likely to cause confusion when you come back to this code in a year.
It doesn't leave you with a dangling reference to the last item in the array. Consider this code:
$array = array(1,2,3,4,5);
foreach($array as &$number){
$number++;
}
// ... some time later in an unrelated section of code
$number = intval("100");
// now unexpectedly, $array[4] == 100 instead of 6
我想这取决于你更注重代码可读性/可维护性还是最小化内存使用。第二种方法会稍微节省一些内存，但我实际上更喜欢第一种用法，因为在PHP中，在foreach定义中通过引用赋值似乎不是常见的做法。
个人而言，如果我想要像这样就地修改一个数组，我会选择第三种选项：
array_walk($array, function(&$value) {
$value++;
});
Closure类的一个实例？除了array_map之外，那不需要最多的内存吗... - Elias Van Ootegemarray_map 吗？它的设计初衷是用来修改数组内部的值的。$array = array(1,2,3,4,5);
$new = array_map(function($number){
return $number++ ;
}, $array) ;
var_dump($new) ;
我会选择#2，但这是个人偏好。
我不同意其他答案，使用foreach循环中数组项的引用是相当常见的，但这取决于你使用的框架。像往常一样，在项目或框架中尽量遵循现有的编码约定。
我也不同意其他答案建议使用array_map或array_walk。这会为每个数组元素引入函数调用的开销。对于小型数组，这不会有太大影响，但对于大型数组，这将为这样一个简单的函数增加重大开销。但如果你正在执行更重要的计算或操作，则它们是适当的——你需要根据情况决定使用哪种方法，可能通过基准测试来决定。
foreach来递增一个数字？不，这不是foreach的用途。该示例旨在向您展示可以通过引用使用值。可以认为array_map、array_walk等是更好的解决方案；但这实际上取决于上下文... - Rob W