Encapsuler la logique de array_filter () en composants multiplexés

Dans PHP, Array_Filter () est une fonction très puissante qui peut filtrer les tableaux en fonction de la fonction de rappel que nous transmettons. Cependant, dans de grands projets ou scénarios où la logique de filtrage similaire est utilisée à plusieurs endroits, écrivant directement des fonctions anonymes à chaque point d'appel n'est pas propice à la réutilisation et à la maintenance du code. Cet article présentera comment encapsuler la logique de filtrage de Array_Filter () dans un composant réutilisable pour rendre votre code plus élégant et maintenable.

1. Examen de l'utilisation de base

Regardons d'abord l'utilisation la plus élémentaire:

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

// Filtrez les nombres uniformes
$filtered = array_filter($data, function($item) {
    return $item % 2 === 0;
});

print_r($filtered);

Bien que le code ci-dessus soit simple, si nous avons besoin de la logique de "filtrage des nombres même" à plusieurs endroits, nous serons confrontés au problème de la duplication de code.

2. Encapsulation Filtrage de la logique en classe

Nous pouvons encapsuler la logique de filtrage couramment utilisée dans une classe et l'appeler via une interface unifiée pour obtenir la réutilisabilité.

 class ArrayFilter
{
    protected array $data;

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

    public function filter(callable $callback): array
    {
        return array_filter($this->data, $callback);
    }
}

Comment utiliser:

 $data = [1, 2, 3, 4, 5];
$filter = new ArrayFilter($data);

$result = $filter->filter(function ($item) {
    return $item % 2 === 0;
});

print_r($result);

3. Encapsuler indépendamment la logique du filtre dans les classes de politique

Afin de découpler davantage la logique, nous pouvons encapsuler les conditions de filtre dans des "classes de stratégie":

 interface FilterStrategyInterface
{
    public function apply($item): bool;
}

class EvenNumberFilter implements FilterStrategyInterface
{
    public function apply($item): bool
    {
        return $item % 2 === 0;
    }
}

Modifiez ensuite la classe ArrayFilter pour recevoir cette politique:

 class StrategyArrayFilter
{
    protected array $data;

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

    public function filter(FilterStrategyInterface $strategy): array
    {
        return array_filter($this->data, [$strategy, 'apply']);
    }
}

Comment utiliser:

 $data = [1, 2, 3, 4, 5];
$filter = new StrategyArrayFilter($data);

$result = $filter->filter(new EvenNumberFilter());

print_r($result);

De cette façon, chaque logique de filtrage peut être définie séparément comme une classe, mettant en œuvre une bonne structure d'organisation de code pour des tests et une réutilisation faciles.

4. Filtre d'enregistrement dynamique

Si vous souhaitez configurer les filtres de manière plus flexible (comme sélectionner des politiques basées sur des fichiers de configuration), vous pouvez ajouter une "classe d'usine" ou "mécanisme d'enregistrement de service". Voici un exemple d'enregistrement de service simple:

 class FilterFactory
{
    public static function create(string $type): FilterStrategyInterface
    {
        return match ($type) {
            'even' => new EvenNumberFilter(),
            default => throw new InvalidArgumentException("Unknown filter type: $type")
        };
    }
}

L'utilisation est la suivante:

 $filterType = 'even'; // Assumer à partir de la configuration ou de l'entrée utilisateur
$strategy = FilterFactory::create($filterType);

$filter = new StrategyArrayFilter([1, 2, 3, 4, 5]);
$result = $filter->filter($strategy);

print_r($result);

5. Résumé

En encapsulant la fonction de rappel de Array_Filter () dans une classe, nous pouvons implémenter une structure de code plus claire et plus facile à tester et à maintenir le code. Ce modèle de stratégie est très adapté à la gestion de la logique de filtrage complexe ou variable, en particulier dans les grandes applications.