Use immutable arrays by returning new arrays instead of modifying originals; 2. Apply higher-order functions like array_map, array_filter, and array_reduce for clean transformations; 3. Chain operations using nested calls or a Collection class to create functional pipelines; 4. Write pure functions with closures to avoid side effects and enhance reusability; overall, PHP supports functional programming with associative arrays through disciplined use of these techniques, improving code clarity and maintainability.

PHP is often seen as a procedural or object-oriented language, but it can also support functional programming (FP) paradigms—especially when working with associative arrays. While PHP wasn’t designed from the ground up for functional programming like Haskell or Clojure, it offers enough tools (closures, higher-order functions, immutability patterns) to apply key FP concepts effectively.

Here’s how you can use functional programming techniques with PHP’s associative arrays.

1. Immutability and Pure Functions

In functional programming, data should not be mutated. Instead of modifying an associative array in place, return a new one.

Bad (mutation):

$user = ['name' => 'Alice', 'age' => 30];
$user['active'] = true; // Mutates original

Better (immutability):

function withActiveStatus(array $user): array {
    return ['active' => true]   $user; // New array, original unchanged
}

$user = ['name' => 'Alice', 'age' => 30];
$updatedUser = withActiveStatus($user);

Using the operator merges arrays from right to left, preserving the original. This pattern encourages pure functions—functions that don’t cause side effects and always return the same output for the same input.

2. Higher-Order Functions: map, filter, reduce

PHP provides built-in functions that align well with FP: array_map, array_filter, and array_reduce. When used with associative arrays, they help transform, select, and aggregate data cleanly.

Transform with array_map

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

$names = array_map(fn($user) => $user['name'], $users);
// Result: ['Alice', 'Bob']

Note: array_map preserves keys, which is useful when working with indexed or keyed associative data.

Filter with array_filter

$adults = array_filter($users, fn($user) => $user['age'] >= 30);
// Returns only users where age >= 30

You can also preserve keys (which is default), or reindex later with array_values() if needed.

Aggregate with array_reduce

$totalAge = array_reduce($users, fn($carry, $user) => $carry   $user['age'], 0);
// Result: 55

These functions avoid loops and make intent clearer—each expresses a specific transformation.

3. Chaining Operations (Functional Pipelines)

You can chain operations by nesting or using a fluent style. While PHP doesn’t have built-in method chaining for arrays, you can wrap arrays in a simple class or use nested function calls.

Example: Nested calls

$averageAdultAge = array_reduce(
    array_filter($users, fn($u) => $u['age'] >= 30),
    fn($carry, $u) => $carry   $u['age'],
    0
) / count(array_filter($users, fn($u) => $u['age'] >= 30));

Alternatively, use a helper to enable chaining:

class Collection {
    private array $items;

    public function __construct(array $items) {
        $this->items = $items;
    }

    public function map(callable $fn): self {
        return new self(array_map($fn, $this->items));
    }

    public function filter(callable $fn): self {
        return new self(array_filter($this->items, $fn));
    }

    public function reduce(callable $fn, $initial) {
        return array_reduce($this->items, $fn, $initial);
    }

    public function toArray(): array {
        return $this->items;
    }
}

// Usage
$avg = (new Collection($users))
    ->filter(fn($u) => $u['age'] >= 30)
    ->map(fn($u) => $u['age'])
    ->reduce(fn($sum, $age) => $sum   $age, 0);

$average = $avg / count(array_filter($users, fn($u) => $u['age'] >= 30));

This mimics functional pipelines seen in JavaScript or Elixir.

4. Avoiding Side Effects and Using Closures

Closures in PHP (anonymous functions) are essential for FP. They can capture context and are first-class values.

function createGreeter(string $greeting) {
    return fn($name) => "$greeting, $name!";
}

$sayHello = createGreeter("Hello");
$greetUsers = array_map($sayHello, $names);

This avoids global state and promotes reusable, composable logic.

Also, avoid functions that modify external variables:

$counter = 0;
array_map(function ($item) use (&$counter) { $counter  ; }, $array); // Impure!

Instead, calculate counts functionally:

$count = array_reduce($array, fn($c, $i) => $c   1, 0);

Summary

You can apply functional programming principles in PHP with associative arrays by:

• Treating arrays as immutable
• Using array_map, array_filter, and array_reduce for transformations
• Building pipelines through composition or wrapper classes
• Writing pure functions and avoiding side effects
• Leveraging closures for configurability and encapsulation

While PHP lacks some FP features (like pattern matching or lazy evaluation), these patterns improve code clarity, testability, and maintainability.

Basically, you don’t need a purely functional language to write functionally—just discipline and the right abstractions.

The above is the detailed content of Functional Programming Paradigms with PHP's Associative Arrays. For more information, please follow other related articles on the PHP Chinese website!