Use array_map and array_reduce to replace overused foreach, making PHP code simpler, readable and easier to test. 1. Use array_map to replace loops to convert data, avoid manually managing arrays and mutable states, and make the intention clearer; 2. Use array_reduce to aggregate arrays as a single value or structure, and avoid external variables and side effects through initial values and accumulators; 3. Use array_map, array_filter and array_reduce to build a readable data processing pipeline to improve composition and expressiveness; 4. Pay attention to always providing initial values for array_reduce, understand the advanced usage of array_map such as number combination, and at the same time weighing memory usage and scenario requirements. Foreach can still be used in simple side effects operations. The key is to prioritize functional tools when transforming or reducing data.

When working with arrays in PHP, many developers reach for foreach as the default tool—understandably so, since it's intuitive and flexible. But overusing foreach can lead to verbose, important code that's harder to test, debug, and reason about. Stepping beyond foreach , embracing functional programming techniques with array_map and array_reduce , can make your code cleaner, more expressive, and less error-prone.

These functions encourage immutability, avoid side effects, and promote a declarative style—core principles of functional programming. Let's explore how to use them effectively.

1. Replace Loops with array_map for Transformations

Use array_map when you want to transform each element in an array and return a new array with the results.

Instead of this important foreach loop:

 $names = ['alice', 'bob', 'charlie'];
$capitalized = [];

foreach ($names as $name) {
    $capitalized[] = ucfirst($name);
}

You can write it functionally:

 $capitalized = array_map('ucfirst', $names);

Or with a custom transformation using an anonymous function:

 $users = [
    ['name' => 'alice', 'age' => 25],
    ['name' => 'bob', 'age' => 30]
];

$userGreeting = array_map(function ($user) {
    return "Hello, {$user['name']}! You're {$user['age']} years old.";
}, $users);

Why it's better:

• No manual array management ( [] = )
• No mutable state
• Clear intent: transform every item
• Easier to chain or compose

2. Use array_reduce to Aggregate or Build Values

When you need to boil down an array into a single value (or structure), array_reduce is your go-to.

Common use cases: summing values, building strings, grouping data, or reducing to a complex structure.

Example: Summing scores

 $scores = [85, 92, 78, 96];

$total = array_reduce($scores, function ($carry, $score) {
    return $carry $score;
}, 0);

More advanced: Group users by age

 $users = [
    ['name' => 'Alice', 'age' => 25],
    ['name' => 'Bob', 'age' => 30],
    ['name' => 'Charlie', 'age' => 25]
];

$grouped = array_reduce($users, function ($carry, $user) {
    $age = $user['age'];
    if (!isset($carry[$age])) {
        $carry[$age] = [];
    }
    $carry[$age][] = $user['name'];
    return $carry;
}, []);

Results:

 [
    25 => ['Alice', 'Charlie'],
    30 => ['Bob']
]

Key points:

• $carry holds the accumulated result
• The third parameter is the initial value (important!)
• Avoids external variables and mutation

3. Combine array_map and array_reduce for Powerful Pipelines

You can chain these functions (and others like array_filter ) to create readable data pipelines.

Example: Get a comma-separated list of names over age 25

 $users = [
    ['name' => 'Alice', 'age' => 25],
    ['name' => 'Bob', 'age' => 30],
    ['name' => 'Charlie', 'age' => 20]
];

$result = array_reduce(
    array_map(function ($user) {
        return $user['name'];
    }, 
    array_filter($users, function ($user) {
        return $user['age'] > 25;
    })),
    function ($carry, $name) {
        return $carry === '' ? $name : "$carry, $name";
    },
    ''
);
// Results: "Bob"

Even better: Use array_column to simplify:

 $namesOver25 = array_filter($users, fn($u) => $u['age'] > 25);
$names = array_column($namesOver25, 'name');
$result = implode(', ', $names);

But the point stands: functional tools compose well and make transformations explicit.

4. Mind the Gotchas

• Always provides an initial value in array_reduce , especially when returning strings, arrays, or objects.
• array_map with null as callback can zip arrays:

   $result = array_map(null, [1,2,3], ['a','b','c']); 
  // [[1,'a'], [2,'b'], [3,'c']]]

• These functions return new arrays , so memory usage may increase with large datasets.
• For simple loops with side effects (eg, sending emails), foreach is still fine—functional style isn't always the goal.

---

Using array_map and array_reduce isn't about dogma—it's about choosing the right tool. When you're transforming or reducing data, these functions make your code more predictable and easier to test. They shift focus from how to what , which is the essence of clean, functional-style programming in PHP.

Basically: if you're building a new array from an old one, reach for array_map . If you're collapse data into a summary, use array_reduce . And sometimes, it's OK to keep using foreach —just don't default to it.

The above is the detailed content of Beyond `foreach`: Embracing Functional Programming with `array_map` and `array_reduce`. For more information, please follow other related articles on the PHP Chinese website!