Programmation fonctionnelle PHP approfondie: Exploration des transducteurs

Vous avez peut-être entendu parler de programmation fonctionnelle et de fonctions avancées, mais connaissez-vous les transducteurs? Cet article vous amènera à explorer cet outil de conversion de données puissant.

Points de base:

• Les transducteurs provenant de Clojure et portés à PHP par Michael Dowling, est un moyen puissant de construire des transformations d'algorithmes réutilisables. Ce sont des fonctions qui acceptent une fonction de réduction et renvoient une autre fonction de réduction.
• Le package Transducers de PHP permet de convertir les données de diverses manières, telles que la capitalisation des initiales des noms ou la suppression des mineurs des listes d'utilisateurs. Les transformations peuvent être combinées en un seul transducteur de réutilisation.
• La fonction de réduction du transducteur re?oit une valeur en tant que paramètre et renvoie un tableau de fonctions de réduction contenant trois éléments: "init" (init), "résultat" (résultat final) et "étape" (réduction) logique).
• L'avantage des transducteurs est qu'il sépare le processus de conversion des données de la source de données réelle, ce qui rend le code plus modulaire et plus facile à maintenir. Ils permettent la création de composants logiciels réutilisables qui peuvent être utilisés dans n'importe quelle source de données. Cependant, en raison de leurs racines de programmation fonctionnelle, ils peuvent être plus complexes que les fonctions PHP traditionnelles.

Définition des transducteurs

Pour comprendre les transducteurs, vous devez d'abord comprendre les réducteurs. Citant Rich Hickey:

Une fonction de réduction est exactement le type de fonction que vous transmettez à reduce - il re?oit le résultat jusqu'à présent et une nouvelle entrée et renvoie le résultat suivant jusqu'à présent.

Un transducteur est une fonction qui re?oit une fonction de réduction et renvoie une autre fonction de réduction.

Les transducteurs ont été initialement introduits à Clojure par Rich Hickey et portés à PHP par Michael Dowling. Les transducteurs sont un moyen puissant de construire des transformations algorithmiques qui peuvent être réutilisées dans une variété de situations. Cet article explorera son utilisation à travers une série d'exemples pratiques.

Exemple

Avant de continuer, nous devons installer le package Transducers via Composer.

composer require mtdowling/transducers

Nous utiliserons une classe utilisateur simple pour l'exemple suivant.

class User
{
    public $id;
    public $name;
    public $age;

    public function __construct($id, $name, $age)
    {
        $this->id = $id;
        $this->name = $name;
        $this->age = $age;
    }

    public function __toString()
    {
        return sprintf("\n%d - %s - %d", $this->id, $this->name, $this->age);
    }
}

// 示例數(shù)據(jù)
$data = [
    new User(1, "younes", 24),
    new User(2, "youssef", 26),
    new User(3, "hamza", 25),
    new User(4, "ismail", 17),
];

use Transducers as t;

$uppercase = t\map(function($user) { 
    return new User($user->id, ucfirst($user->name), $user->age); 
});

$result = t\xform($data, $uppercase);

var_dump($result);

map est similaire à la fonction array_map de PHP: nous passons une fonction appelable, qui dans ce cas capitalisera l'initiale du nom d'utilisateur.

Nous utilisons la fonction xform pour appliquer notre transducteur uppercase. Il prend nos données comme premier paramètre et le transducteur comme deuxième paramètre.

// 輸出
array(4) {
  [0]=>
  object(User)#14 (3) {
    ["id"]=>
    int(1)
    ["name"]=>
    string(6) "Younes"
    ["age"]=>
    int(24)
  }
  [1]=>
  object(User)#15 (3) {
    ["id"]=>
    int(2)
    ["name"]=>
    string(7) "Youssef"
    ["age"]=>
    int(26)
  }
  [2]=>
  object(User)#16 (3) {
    ["id"]=>
    int(3)
    ["name"]=>
    string(5) "Hamza"
    ["age"]=>
    int(25)
  }
  [3]=>
  object(User)#17 (3) {
    ["id"]=>
    int(4)
    ["name"]=>
    string(6) "Ismail"
    ["age"]=>
    int(17)
  }
}

xform Renvoie une valeur du même type que le paramètre de données (dans ce cas un tableau). Si vous avez strictement besoin de produire un tableau, nous pouvons également utiliser to_array.

// ...
$result = t\to_array($data, $uppercase);
// ...

Nous pouvons également utiliser to_string pour convertir la sortie en une cha?ne, ou utiliser into($target, $coll, callable $xf) pour convertir la sortie en un type spécifique. Pour plus de détails, veuillez consulter la documentation.

composer require mtdowling/transducers

class User
{
    public $id;
    public $name;
    public $age;

    public function __construct($id, $name, $age)
    {
        $this->id = $id;
        $this->name = $name;
        $this->age = $age;
    }

    public function __toString()
    {
        return sprintf("\n%d - %s - %d", $this->id, $this->name, $this->age);
    }
}

// 示例數(shù)據(jù)
$data = [
    new User(1, "younes", 24),
    new User(2, "youssef", 26),
    new User(3, "hamza", 25),
    new User(4, "ismail", 17),
];

La meilleure partie des transducteurs est que nous pouvons combiner plusieurs conversions en un seul transducteur. Par exemple, capitalisons la lettre initiale du nom d'utilisateur et supprimons le mineur.

use Transducers as t;

$uppercase = t\map(function($user) { 
    return new User($user->id, ucfirst($user->name), $user->age); 
});

$result = t\xform($data, $uppercase);

var_dump($result);

filter est similaire à la fonction array_filter de PHP. La fonction comp crée un transducteur à partir de la liste des transducteurs, dans ce cas uppercase (en utilisant map) et removeMinors (en utilisant filter).

// 輸出
array(4) {
  [0]=>
  object(User)#14 (3) {
    ["id"]=>
    int(1)
    ["name"]=>
    string(6) "Younes"
    ["age"]=>
    int(24)
  }
  [1]=>
  object(User)#15 (3) {
    ["id"]=>
    int(2)
    ["name"]=>
    string(7) "Youssef"
    ["age"]=>
    int(26)
  }
  [2]=>
  object(User)#16 (3) {
    ["id"]=>
    int(3)
    ["name"]=>
    string(5) "Hamza"
    ["age"]=>
    int(25)
  }
  [3]=>
  object(User)#17 (3) {
    ["id"]=>
    int(4)
    ["name"]=>
    string(6) "Ismail"
    ["age"]=>
    int(17)
  }
}

Maintenant, nous avons une combinaison de transducteurs réutilisable que nous pouvons utiliser à tout moment pour réduire les données en fonction de cette norme. Consultez la documentation pour une liste des fonctions de réduction disponibles.

Créer un transducteur

La fonction de réduction re?oit une valeur en tant que paramètre et renvoie un tableau de fonctions de réduction qui doivent contenir trois éléments:

• init: fonction qui renvoie la valeur initiale du transducteur. Si aucune valeur initiale n'est fournie, elle est appelée uniquement lors du premier appel.
• result: result La fonction est utilisée pour construire le résultat final de la pile d'appels.
• step: C'est là que vous écrivez la logique de réduction - vous pouvez l'appeler zéro ou plusieurs fois selon votre logique de réduction.

Cela devient très déroutant sans code réel, alors prenons la fonction take Transducer comme exemple. Il obtient N éléments du haut du tableau de données.

// ...
$result = t\to_array($data, $uppercase);
// ...

use Transducers as t;

$uppercase = t\map(function($user) { 
    return new User($user->id, ucfirst($user->name), $user->age); 
});

$result = t\to_string($data, $uppercase);

var_dump($result);

Ce qui suit est le code source de la fonction de réduction take.

// 輸出
string(64) "
1 - Younes - 24
2 - Youssef - 26
3 - Hamza - 25
4 - Ismail - 17"

take est appelée plusieurs fois avec des paramètres result et input. Chaque fois qu'il est appelé, il diminue la variable remaining et teste s'il est inférieur à zéro. Dans ce cas, nous renvoyons une instance d'objet Reduced, qui représente un point d'arrêt.

Notre exemple de fonction de transducteur supprimera les éléments vides des données. En utilisant l'explication précédente du fonctionnement du transducteur, nous pouvons accéder à la variable $input et décider d'appeler le rappel suivant step ou simplement renvoyer la valeur.

$uppercase = t\map(function($user) { 
    return new User($user->id, ucfirst($user->name), $user->age); 
});
$removeMinors = t\filter(function($user) { 
    return $user->age >= 18;
});

$comp = t\comp(
    $uppercase,
    $removeMinors
);

$result = t\to_string($data, $comp);

var_dump($result);

Nous pouvons tester cela en ajoutant des éléments vides à notre variable $data.

// 輸出
string(48) "
1 - Younes - 24
2 - Youssef - 26
3 - Hamza - 25"

// ....
$comp = t\comp(
    $uppercase,
    $removeMinors,
    t\take(2)
);

$result = t\to_string($data, $comp);

var_dump($result);

Conclusion

Dans cet article, nous comprenons un nouvel aspect du monde de la programmation fonctionnelle appelée transducteurs. Nous passons en revue l'objectif des transducteurs, même si la conversion des données est plus facile. Nous avons également examiné quelques exemples pour mieux démontrer la valeur des transducteurs. Vous avez maintenant un nouvel outil dans votre bo?te à outils de développeur, ou du moins avez une meilleure compréhension du concept de transducteur.

Si vous avez des questions sur les transducteurs, vous pouvez le publier ci-dessous!

FAQ sur les transducteurs dans PHP

Quel est le concept de base des transducteurs dans PHP?

Les transducteurs dans PHP sont une technologie de traitement des données qui vous permet de créer des composants logiciels composables et réutilisables. Ce sont essentiellement des fonctions qui acceptent un réducteur et renvoient un nouveau réducteur. Ce concept est emprunté à Clojure et JavaScript et s'est adapté à PHP. Les transducteurs vous permettent de séparer le processus de conversion des données de la source de données réelle, ce qui rend votre code plus modulaire et plus facile à maintenir.

En quoi les transducteurs sont-ils différents des fonctions PHP traditionnelles?

Les fonctions PHP traditionnelles combinent généralement le processus d'obtention et de conversion des données, ce qui peut rendre le code difficile à maintenir et à réutiliser. Les transducteurs, en revanche, séparent les deux processus. Cela signifie que vous pouvez créer un transducteur qui convertit les données de manière spécifique, puis les utiliser avec n'importe quelle source de données pour rendre votre code plus flexible et réutilisable.

Pouvez-vous fournir un exemple de transducteur dans PHP?

Bien s?r, considérons un exemple simple. Supposons que vous ayez un tableau de nombres et que vous souhaitez ajouter 1 à chaque numéro. Vous pouvez créer un transducteur qui fait cela:

composer require mtdowling/transducers

Vous pouvez ensuite utiliser ce transducteur avec toute fonction de réduction et source de données.

Comment utiliser les transducteurs avec différentes sources de données?

sont con?us pour être utilisés avec n'importe quelle source de données. En effet, ils s'exécutent au niveau des éléments de données uniques, pas au niveau de la source de données. Par conséquent, vous pouvez utiliser le transducteur avec des tableaux, les résultats de la requête de la base de données, les flux de données à partir des connexions réseau, etc. La seule exigence est que votre source de données doit pouvoir travailler avec la fonction de réduction.

Quels sont les avantages de l'utilisation des transducteurs en PHP?

Les transducteurs offrent de nombreux avantages. Ils vous permettent de séparer le processus de conversion des données de la source de données réelle, ce qui rend votre code plus modulaire et plus facile à entretenir. Ils vous permettent également de créer des composants logiciels réutilisables qui peuvent être utilisés dans n'importe quelle source de données. Enfin, comme les transducteurs fonctionnent sur un seul élément de données, ils peuvent être plus efficaces que les fonctions PHP traditionnelles lorsqu'ils traitent de grands ensembles de données.

Quels sont les inconvénients de l'utilisation des transducteurs en PHP?

Bien que les transducteurs offrent de nombreux avantages, ils peuvent également être plus complexes que les fonctions PHP traditionnelles. En effet, ils impliquent les concepts de programmation fonctionnelle qui peuvent ne pas être familiers à certains développeurs PHP. Mais une fois que vous comprenez comment fonctionnent les transducteurs, ils peuvent être un outil puissant pour écrire un code propre, efficace et réutilisable.

Les transducteurs peuvent-ils être utilisés avec des cadres PHP?

Oui, les transducteurs peuvent être utilisés avec n'importe quel cadre PHP. Il s'agit d'une technologie générale de traitement des données qui ne dépend d'aucune caractéristique de framework spécifique. Cependant, certains cadres peuvent fournir leurs propres services publics pour gérer les transducteurs, ce qui peut les rendre plus faciles à utiliser.

Comment en savoir plus sur les transducteurs dans PHP?

Il existe de nombreuses ressources disponibles pour apprendre les transducteurs en PHP. Vous pouvez commencer par lire des articles et des tutoriels en ligne, tels que des articles sur SitePoint. Il y a aussi des livres et des cours en ligne qui couvrent le sujet plus en profondeur. Enfin, vous pouvez essayer d'écrire vos propres transducteurs et de les utiliser dans votre projet PHP.

Les transducteurs sont-ils utilisés dans d'autres langages de programmation?

Oui, le concept de transducteurs provenait du langage de programmation Clojure et a depuis été adopté par plusieurs autres langues, dont JavaScript et PHP. Chaque langue implémente les transducteurs à sa manière, mais les concepts de base sont les mêmes.

Puis-je utiliser des transducteurs avec des fonctions de tableau intégrées PHP?

Oui, vous pouvez utiliser des transducteurs avec les fonctions de tableau intégrées de PHP. Cependant, n'oubliez pas que ces fonctions peuvent ne pas être aussi efficaces que l'utilisation du transducteur, en particulier lorsqu'ils traitent de grands tableaux. En effet, les fonctions de tableau de PHP créent généralement de nouveaux tableaux, et le transducteur peut convertir les données en place.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!