Foreach by reference or by value?

Question

Is there a difference in performance and safety between using foreach by reference or by value? I always use the first option(when necessary) by finding the code less confusing to read.

Reference:

Here I trade all values of an array for the string exemplo using reference passage.

foreach ($array as $key => &$value) {
    $value = 'exemplo';
}

Valor:

Here I trade all values of an array for the string exemplo using pass by value.

foreach ($array as $key => $value) {
    $array[$key]= 'exemplo';
}

Example:

Here is an example of a code of mine (with a few lines removed to make it easier to understand) in which I do what some answers and comments say would go wrong, but I have no mistake:

foreach ($array as $key => &$value) {
    //Removida as linhas em que calculo alguns valores para a substr.
    $value['arq_descricao'] = substr($value['pes_texto'], $inicio, $tamanho);
}

Answer 1

Performance

I’m not an expert on the subject, but I can assure you that the performance in this case doesn’t make so much of a difference that it’s worth choosing one or the other because of it.

Safety - Understanding each other’s behavior

The only safety that is at risk is yours. I say this because it is necessary to understand the behavior of references in this case.

How it was answered in this question there is a small variation from what is expected of a normal foreach in relation to the variable passed by reference.

In short: The last value is always referenced, it can cause you problems if you overwrite the value of $value.

$array = [1, 2, 3];

foreach ($array as $key => &$value) {
    $value = $value . 'R$';
}

$value = null;

That would generate:

['1R$', '2R$', null]

See an example on IDEONE

So after using a foreach with reference, it is always good to call unset on the referenced variable (after the loop).

_{I won’t talk about it much here, because the linked question has enough on the subject.}

In this case, I’m not telling you not to do it like this (I’ve done it a few times). I’m just warning you that you better know everything about it, so that "you don’t know" causes you problems.

But, noting that may arise a "new behavior" in relation to the first foreach - and at the same time, it can also affect readability if you forget to treat the reference variable properly-, I could think of your second option as being the best.

$array = [1, 2, 3];

foreach ($array as $key => $value) {
    $array[$key] = $value . 'R$';
}

But it is necessary to know if it is necessary and if it is wise to change the original value of your array. If you’re sure you won’t be using the array ""original, so you can do it without fear of being happy :p

The reference disadvantage with foreach

Remembering that also you have a disadvantage when using foreach with reference: You can only loop with the array stored in variables. Arbitrary expressions cannot be used with reference in some versions of PHP prior to 5.5.

Example:

// Certo:

$array = [];

foreach ([1, 2, 3, 4] as $key => $value) {
    $array[$key] = $value . 'R$';
}

// Errado: Isso vai gerar um erro caso use PHP 5.4

foreach ([1, 2, 3, 4] as $key => &$value) {
    $value = $value . 'R$';
}

See a small test

Draw your own conclusion

I don’t want to give you an opinion on the subject, I just want you to understand that do a foreach with reference and do a reallocation with the keys of the foreach may seem like the same thing, but technically it’s not. References can be villainous if not used wisely. Similarly overwrite a value of a array might not be a good idea if you want to keep the original values.

I’m showing you some points, because this "good practice" thing is actually pretty personal. Always better you know what you’re doing and know how to use it at the right time.

Answer 2

If you really need the key($key) you use the second option, because sometimes I need to change the value of the variable, for example:

$ar = ['a'=>'x','b'=>'y'];
    foreach($ar as $key => $value){
        $ar[$key] = $value+'alterado';
}

Now if you’re not going to change the value of the parent array ($ar), or use $key, the performance and reading are better (changes almost nothing, but are better)

Answer 3

When you work with value you have a new instance of the array. When you work with reference, you modify the original array.

Basically, when you use the array by value you have a copy of that valid array only within the scope of foreach, for, while and the like.

Run the example below to get an idea.

<?php

$array = ['a','b','c','d','e'];

echo "Array original";
echo "<pre>";
print_r($array);
echo "</pre>";

foreach($array as $k => $v) {
    $v = $k;
}

echo "Array após foreach por valor";
echo "<pre>";
print_r($array);
echo "</pre>";

foreach($array as $k => &$v) {
    $v = $k;
}

echo "Array após foreach por referência";
echo "<pre>";
print_r($array);
echo "</pre>";