Что лучше в цикле foreach ... используя символ & или переназначение на основе ключа?

поскольку самый высокий балльный ответ утверждает, что второй метод лучше во всех отношениях, я чувствую себя вынужденным опубликовать ответ здесь. Верно, зацикливание по ссылке is более эффективный, но это не без рисков/подводных камней.
Итог, как всегда: "что лучше, X или Y", единственные реальные ответы, которые вы можете получить:

• это зависит от того, что вы После / что вы делаете
• о, оба в порядке, если вы знаете, что вы делать
• X хорошо для такие, Y лучше для так
• не забывайте о Z, и даже тогда ...( "что лучше X, Y или Z" тот же вопрос, поэтому применяются те же ответы: это зависит, оба в порядке, если...)

как бы то ни было, как показал Orangepill, эталонный подход обеспечивает лучшую производительность. В этом случае компромисс между производительностью и кодом, который менее подвержен ошибкам, проще читать/maintan. В общем, считается, что лучше пойти на более безопасный, надежный и более ремонтопригодный код:

'отладка в два раза сложнее, чем написание кода в первую очередь. Поэтому, если вы пишете код как можно умнее, вы, по определению, недостаточно умны, чтобы отладить его.- Брайан Керниган!--26-->

я думаю, это означает, что первый способ должен считаться лучшие практики. Но это не значит, что второй подход следует избегать в любое время, так что ниже приведены недостатки, подводные камни и причуды, которые вам придется учитывать при использовании ссылки в foreach петли:

объем:
Для начала PHP не является действительно блочным, как C (++), C#, Java, Perl или (с некоторой удачей) ECMAScript6... Это означает, что $value переменная не будет unset как только цикл закончился. При циклировании по ссылке это означает ссылку на последнее значение любого объекта / массива, который вы повторяли, плавает вокруг. Фраза "что-то случиться" должно прийти на ум.
Подумайте, что происходит с $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 переменные, которые были используется в цикле (мы предполагаем, что GC позаботится об этом для нас), поэтому большую часть времени вы не беспокоитесь. Когда ссылки задействованы, это источник разочарования, таинственные сообщения об ошибках или путешествия значений, когда вы используете сложные вложенные циклы, возможно, с несколькими ссылками... Ужас, ужас.
Кроме того, с течением времени, кто может сказать, что следующий человек, работающий над вашим кодом, не будет foget о 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]

чтобы противостоять этому, нам придется либо создать временную переменную, либо вызвать функцию tiwce, либо добавить ключ и пересчитать начальное значение $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;
    }
}

в любом случае, добавление ветвей, временных переменных и что у вас есть, скорее поражает точка. Во-первых, он вводит дополнительные накладные расходы, которые съедят в ссылках на преимущества производительности, которые вы дали в первую очередь.
Если вам нужно добавить логику в цикл, чтобы исправить то, что не должно нуждаться в исправлении, вы должны отступить назад и подумать о том, какие инструменты вы используете. 9/10 раз, вы выбрали неправильный инструмент для работы.

последнее, что, по крайней мере для меня, является убедительным аргументом для первого метода, просто: читабельности. Оператор ссылки (&) легко упускается из виду, если вы делаете некоторые быстрые исправления или пытаетесь добавить функциональность. Вы можете создавать ошибки в коде, который работает нормально. Более того: поскольку он работал нормально, вы не можете проверить существующую функциональность так тщательно , потому что не было никаких известных проблем.
Обнаружение ошибки, которая вошла в производство, из-за вашего игнорирования оператора может показаться глупым, но вы не будете первым, кто столкнулся с этим.

Примечание:
Передача по ссылке во время вызова была удалена с 5.4. Устаньте от функций / функций, которые могут быть изменены. стандартная итерация массива не менялась годами. Я думаю, это то, что вы могли бы назвать "проверенные технологии". Он делает то, что говорит на олове, и это более безопасный способ делать вещи. Что с того, что он медленнее? Если скорость является проблемой, вы можете оптимизировать свой код и ввести ссылки на тогда твои петли.
При написании нового кода перейдите к удобному для чтения, наиболее надежному варианту. Оптимизация может (и действительно должны) подождите, пока все не будет проверено.

и как всегда: преждевременная оптимизация-корень всего зла. И выбрать правильный инструмент для работы, а не потому что он новый и блестящий.