PHP Functional Programming and Design Patterns

Functional programming uses immutable values ​​and function applications to improve code stability. Combined with design patterns, it creates efficient and easy-to-maintain applications. For example, the Strategy pattern uses a mapping function to select an algorithm, and we demonstrated sorting an array using the Bubble Sort and Quick Sort strategies.

PHP Functional Programming and Design Patterns

Functional Programming is a programming paradigm that Think of computations as applying functions to immutable values ​​rather than executing commands on state. It brings greater stability and maintainability to the code.

Design patterns are proven, reusable code structures that solve common programming problems. Combining functional programming and design patterns allows you to create efficient and easy-to-maintain applications.

Practical case: Strategy pattern and mapping function

The strategy pattern allows the application to select an algorithm or operation without changing the structure of the application. We can implement the Strategy Pattern using mapping functions as follows:

<?php

interface SortStrategy
{
    public function sort(array $data): array;
}

class BubbleSortStrategy implements SortStrategy
{
    public function sort(array $data): array
    {
        for ($i = 0; $i < count($data); $i++) {
            for ($j = $i + 1; $j < count($data); $j++) {
                if ($data[$i] > $data[$j]) {
                    $temp = $data[$i];
                    $data[$i] = $data[$j];
                    $data[$j] = $temp;
                }
            }
        }
        return $data;
    }
}

class QuickSortStrategy implements SortStrategy
{
    public function sort(array $data): array
    {
        if (count($data) <= 1) {
            return $data;
        }

        $pivot = $data[0];
        $left = [];
        $right = [];

        for ($i = 1; $i < count($data); $i++) {
            if ($data[$i] < $pivot) {
                $left[] = $data[$i];
            } else {
                $right[] = $data[$i];
            }
        }

        return array_merge($this->sort($left), [$pivot], $this->sort($right));
    }
}


$data = [5, 3, 1, 2, 4];

$bubbleSortStrategy = new BubbleSortStrategy();
$sortedData = array_map(function ($value) use ($bubbleSortStrategy) {
    return $bubbleSortStrategy->sort($value);
}, [$data]);

echo implode(', ', $sortedData[0]); // Output: 1, 2, 3, 4, 5


$quickSortStrategy = new QuickSortStrategy();
$sortedData = array_map(function ($value) use ($quickSortStrategy) {
    return $quickSortStrategy->sort($value);
}, [$data]);

echo implode(', ', $sortedData[0]); // Output: 1, 2, 3, 4, 5

In this example, the array_map function serves as the universal caller of the Strategy Pattern. It goes through the data and applies the specified strategy (sorting algorithm) to each element. This way we can easily swap out different sorting algorithms as needed without modifying the structure of the application.

The above is the detailed content of PHP Functional Programming and Design Patterns. For more information, please follow other related articles on the PHP Chinese website!