PHP 5.3 Méthode magique __invoke

L'utilisation de __invoke de sens que si vous avez besoin d'un callable qui doit conserver une certaine état interne. Disons que vous voulez trier le tableau suivant:

$arr = [
    ['key' => 3, 'value' => 10, 'weight' => 100], 
    ['key' => 5, 'value' => 10, 'weight' => 50], 
    ['key' => 2, 'value' => 3, 'weight' => 0], 
    ['key' => 4, 'value' => 2, 'weight' => 400], 
    ['key' => 1, 'value' => 9, 'weight' => 150]
];

La usort fonction permet de trier un tableau en utilisant une fonction très simple. Toutefois, dans ce cas, nous voulons trier le tableau à l'aide de ses propres tableaux 'value' clés, ce qui pourrait être fait de cette façon:

$comparisonFn = function($a, $b) {
    return $a['value'] < $b['value'] ? -1 : ($a['value'] > $b['value'] ? 1 : 0);
};
usort($arr, $comparisonFn);

//['key' => 'w', 'value' => 2] will be the first element, 
//['key' => 'w', 'value' => 3] will be the second, etc

Maintenant peut-être vous avez besoin de trier le tableau de nouveau, mais cette fois en utilisant 'key' comme cible clé, il serait nécessaire de réécrire la fonction:

usort($arr, function($a, $b) {
    return $a['key'] < $b['key'] ? -1 : ($a['key'] > $b['key'] ? 1 : 0);
});

Comme vous pouvez le voir, la logique de la fonction est identique à la précédente, cependant nous ne pouvons pas réutiliser la précédente en raison de la nécessité de trier avec une clé différente. Ce problème peut être résolu avec une classe qui encapsule la logique de comparaison dans la __invoke méthode et qui définissent la clé pour être utilisé dans son constructeur:

class Comparator {
    protected $key;

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

    public function __invoke($a, $b) {
            return $a[$this->key] < $b[$this->key] ? 
               -1 : ($a[$this->key] > $b[$this->key] ? 1 : 0);
    }
}

Un objet de Classe qui implémente __invoke c'est un "callable", il peut être utilisé dans n'importe quel contexte qu'une fonction peut être, alors maintenant, il suffit d'instancier Comparator objets et de les transmettre à l' usort fonction:

usort($arr, new Comparator('key')); //sort by 'key'

usort($arr, new Comparator('value')); //sort by 'value'

usort($arr, new Comparator('weight')); //sort by 'weight'

Les paragraphes suivants reflètent mon opinion subjective, donc, si vous voulez, vous pouvez arrêter la lecture de la réponse maintenant 😉: Bien que l'exemple précédent a montré une utilisation très intéressante de __invokede tels cas sont rares et je voudrais l'éviter car il peut être vraiment déroutant moyens et en général, il est plus simple de mise en œuvre de solutions de rechange. Un exemple d'une alternative dans le même problème de tri serait l'utilisation d'une fonction qui retourne une fonction de comparaison:

function getComparisonByKeyFn($key) {
    return function($a, $b) use ($key) {
            return $a[$key] < $b[$key] ? -1 : ($a[$key] > $b[$key] ? 1 : 0);
    };
}
usort($arr, getComparisonByKeyFn('weight'));
usort($arr, getComparisonByKeyFn('key'));
usort($arr, getComparisonByKeyFn('value'));

Bien que cet exemple nécessite un peu plus d'intimité avec les lambdas | fermetures | fonctions anonymes c'est beaucoup plus concis, car il ne crée pas d'ensemble de la structure de classe juste pour stocker une valeur externe.

C'est une combinaison de deux choses l'une. Vous avez correctement identifié l'un d'entre eux déjà. C'est en effet tout comme Java IRunnable interface, où chaque "praticable" objet implémente la même méthode. En Java, la méthode est nommée run; en PHP, la méthode est nommée __invokeet vous n'avez pas besoin d'implémenter explicitement tout particulier type d'interface à l'avance.

Le deuxième aspect est le sucre syntaxiquedonc au lieu d'appeler $obj->__invoke()vous pouvez ignorer le nom de la méthode, il semble comme si vous êtes à l'appel de l'objet directement: $obj().

La partie clé pour PHP pour avoir des fermetures est le premier. La langue a besoin de quelque méthode établie pour appeler à une fermeture de l'objet pour en faire sa chose. Le sucre syntaxique est juste un moyen de le rendre moins moche, comme c'est le cas avec tous les "spéciaux", des fonctions avec un double trait de soulignement préfixes.

Finales (sur la base de tous les ci-dessus)

Généralement je vois __invoke(){...} la méthode magique comme une grande opportunité pour l'abstraction l'utilisation de la classe de l'objet principal de la fonctionnalité ou pour une utilisation intuitive de l'objet de l'installation (la préparation de l'objet avant de l'utiliser de méthodes).

Cas 1 - la Par exemple permet de dire que j'utilise de la troisième partie de l'objet qui implémente __invoquer la magie de méthode en fournissant de cette façon, un accès facile aux principales fonctionnalités de l'instance d'un objet. Pour l'utiliser caractéristique principale que j'ai seulement besoin de savoir quels sont les paramètres __invoquer la méthode attend et ce que serait le résultat final de cette fonction (la fermeture). De cette façon, je suis en mesure d'utiliser la classe de l'objet principal de fonctionnalités avec peu d'efforts pour investygate l'objet capacités (notez que dans cet exemple nous n'avons pas besoin de connaître ou d'utiliser tout nom de la méthode).

Abstraire du réel code...

au lieu de

$obj->someFunctionNameInitTheMainFunctionality($arg1, $arg2);

que nous utilisons aujourd'hui:

$obj($arg1, $arg2);

Nous pouvons maintenant passer un objet à d'autres fonctions qui attend de ses paramètres pouvant être appelée comme une fonction ordinaire:

au lieu de

someFunctionThatExpectOneCallableArgument($someData, [get_class($obj), 'someFunctionNameInitTheMainFunctionality']);

que nous utilisons aujourd'hui:

someFunctionThatExpectOneCallableArgument($someData, $obj);

__invoquer fournit une belle utilisation du raccourci alors pourquoi ne pas l'utiliser ?