Readability of array_* vs foreach in PHP for filtering and extracting

Question

With functional programming all the rage, I feel I should be using PHP's array_* functions more. But when I compare these two identical implementations, I can't help but think foreach is more readable. Am I just being a dinosaur?

(The foreach implementation takes 1/4 the time, but performance is not of interest for me here, now).

Which do you like better and why?

// Create $attendeeNames from $allPeople who are in the $selectedPeople array
foreach ($allPeople as $person) {
    $id = $person['id'];
    $name = $person['name'];
    if (in_array($id, $selectedPeople)) {
        $attendeeNames[] = $name;
    }
}

// Same, but with array functions
$attendees = array_filter($allPeople, 
    function($item) use ($selectedPeople) {
        $id = $item['id'];
        return in_array($id, $selectedPeople);
    });

$attendeeNames = array_map(
    function($attendee) {
        return $attendee['name'];
    }, $attendees);

Answer 1

If your functional code is a filter and then a map it's likely a good candidate for array_reduce.

One of the main advantages of a function first approach here is that you can name the inner operation (the filtering operation), but using a closure (or a foreach) robs of you of a name (which could have been used to signal intent) and often robs of us of reuse so wrap the Closure in a named, reusable context (another named function).

A named function will also allow us to pre-inject the variable $selectedPeople into the Closure before array_ functions interact with the Closure inside.

See: http://www.phptherightway.com/pages/Functional-Programming.html for more information on this.

Now we can type hint all the inputs.

function selected_attendee_names(array $selectedPeople) : Closure {
  return function (array $attendeeNames, array $attendee) use ($selectedPeople) : array {
    $isSelectedAttendee = in_array($attendee['id'], $selectedPeople);
    $isSelectedAttendee ? $attendeeNames[] = $attendee['name'] : NULL;
    return $attendeeNames;
  };
}

$attendeeNames = array_reduce($allPeope, selected_attendee_names($selectedPeople), []);

Another approach that could have increased reuse is to array_filter and then use array_column.

function is_selected_attendee(array $selectedPeople) : Closure {
  return function (array $attendee) use ($selectedPeople) : bool {
      $isSelectedAttendee = in_array($attendee['id'], $selectedPeople);
      return $isSelectedAttendee;
  };
}

$selected_attendees = array_filter($allPeople, is_selected_attendee($selectedPeople));
$selected_attendees_names = array_column($selected_attendees, 'name');

Generally speaking I'd prefer the bottom approach because you'll usually find you want to do something else with the selected attendees later in your program.

Answer 2

Separation of concerns and single responsibility are the keys here.

Your for loop does two things, but because you know what they are and how they are done it seems (now) easier to read.

When you or (more importantly) someone else will come to the same code later, you will be asking yourself first: "What is going on here?" and only after that: "How is it done?".

And then the array_filter, array_map implementations will be much easier to comprehend. Each chunk of code does exactly one thing. So if you want to know how people are filtered, you look inside the array_filter and if you want to know how the extracting is done - look inside array_map.

You can extract those chunks to separate well-named methods and your code will look even better (Read Clean Code by Uncle Bob). And if your filtering or extracting strategies change you can modify them separately without worrying about breaking the other.

Answer 3

I am in the same boat (or you can call me a dinosaur too). The foreach loop is almost as readadable as natural English, whereas lambda makes you always to stumble. So I would stick to foreach.

As of the code review, I would initialize the resulting array first and also use the O(1) search instead of O(n) as array keys can be found real fast without looping over all values.

$selectedPeopleKeyed = array_flip($selectedPeople);
$attendeeNames = [];
foreach ($allPeople as $person) {
    $id = $person['id'];
    $name = $person['name'];
    if (array_key_exists($id, $selectedPeopleKeyed)) {
        $attendeeNames[] = $name;
    }
}

Answer 4

I just wanted to add an answer that updates this for PHP 7.4 or greater where we have arrow functions. Because they automatically have access to their parent scope's variables without the need for the ugly use() syntax, and the return is implied, there is less boilerplate code which, in theory, makes the code more understandable.

I'm not necessarily saying that this is better or more performant, just that the language is slowing evolving to address some of the uglier syntaxes for common cases.

$attendees = array_filter(
    $allPeople,
    fn($item) => in_array($item['id'], $selectedPeople)
);

Like @arcanine said, the array_column function can then be used to derive the list of names.

$attendeeNames = array_column($attendees, 'name');

Answer 5

I prefer functional programming because of its declarative nature. Combined with high-quality and expressive variable names, a script is most readable/maintainable.

See how I have used native functions (and no custom functions) with clear variable names to make each process clear. The only requirement of the developer is to know what native functions do.

That said, during my years of volunteerism in the Stack Exchange network, it is my belief that (relative to other native array functions) array_reduce() is rarely used even when appropriate (maybe because its syntax is less intuitive or harder to remember) and too few developers know about the existence/utility of the third parameter of array_column().

Code: (Demo)

$people = [
    ['id' => 2, 'name' => 'John Smith', 'gender' => 'male'],
    ['id' => 35, 'name' => 'Gareth Foo', 'gender' => 'male'],
    ['id' => 91, 'name' => 'John Smith', 'gender' => 'male'],
    ['id' => 27, 'name' => 'Bobby Smith', 'gender' => null],
    ['id' => 44, 'name' => 'Jane Doe', 'gender' => 'female'],
];

$selectedIds = [44, 91];

$identifiedNames = array_column($people, 'name', 'id');
$filteredNames = array_intersect_key(
    $identifiedNames,
    array_flip($selectedIds)
);
var_export($filteredNames);

Output:

array (
  91 => 'John Smith',
  44 => 'Jane Doe',
)

Admittedly, my arrays retain the id in the output. This feels appropriate because two "names" could be identical and there should be a way to uniquely identify them. Of course, if you specifically don't want the ids as keys, you only need to call array_values() on the data.