Pourquoi PHP ne supporte-t-il pas la surcharge de fonctions?


37

Je me demande si l’une des principales caractéristiques d’un langage de programmation est d’avoir la capacité de surcharger des fonctions via des arguments. Je pense que c'est essentiel dans le contexte de la programmation orientée objet.

Est-ce intentionnellement laissé derrière et non autorisé? Ou la surcharge n'est-elle pas une bonne pratique?


27
La surcharge de fonctions n’est pas vraiment une fonctionnalité de la programmation OO. La surcharge de fonction de sous-classe à des fins de polymorphisme est généralement considérée comme une caractéristique nécessaire de OO - mais pas de surcharge de fonction basée sur des arguments. Python n'a pas non plus de surcharge de fonction basée sur les arguments. Quoi qu'il en soit, la surcharge de fonctions est probablement plus pratique dans les langages à typage statique où la liaison de fonction se produit au moment de la compilation et est basée sur le type de chaque paramètre de fonction.
Charles Salvia

2
@CharlesSalvia Ce serait une bonne réponse.
Kiamlaluno

1
Ce qu'il a dit. En outre, la surcharge de fonctions est surestimée. Vous n'êtes pas obligé d'utiliser le même nom de fonction pour différentes fonctions; donnez simplement à vos fonctions des noms similaires mais non identiques. Opérateur surchargé en revanche ...
M. Lister

Bien que n'étant pas une réponse à la question spécifique, je posterai ce lien qui m'a permis de mieux comprendre COMMENT utiliser la surcharge en PHP. J'espère que cela vous aidera
DiegoDD

Réponses:


33

Qui vous a dit que PHP ne supporte pas la surcharge de fonctions? !!!

En réalité, PHP supporte la surcharge de fonctions, mais de manière différente. Les fonctionnalités de surcharge de PHP sont différentes de celles de Java:

L'interprétation de "surcharge" par PHP diffère de la plupart des langages orientés objet. La surcharge offre généralement la possibilité d’avoir plusieurs méthodes portant le même nom mais différentes quantités et types d’arguments.

Commander les blocs de code suivants.

Fonction pour trouver la somme de n nombres:

function findSum() {
    $sum = 0;
    foreach (func_get_args() as $arg) {
        $sum += $arg;
    }
    return $sum;
}

echo findSum(1, 2), '<br />'; //outputs 3
echo findSum(10, 2, 100), '<br />'; //outputs 112
echo findSum(10, 22, 0.5, 0.75, 12.50), '<br />'; //outputs 45.75

Fonction pour ajouter deux nombres ou pour concaténer deux chaînes:

function add() {
    //cross check for exactly two parameters passed
    //while calling this function
    if (func_num_args() != 2) {
        trigger_error('Expecting two arguments', E_USER_ERROR);
    }

    //getting two arguments
    $args = func_get_args();
    $arg1 = $args[0];
    $arg2 = $args[1];

    //check whether they are integers
    if (is_int($arg1) && is_int($arg2)) {
        //return sum of two numbers
        return $arg1 + $arg2;
    }

    //check whether they are strings
    if (is_string($arg1) && is_string($arg2)) {
        //return concatenated string
        return $arg1 . ' ' . $arg2;
    }

    trigger_error('Incorrect parameters passed', E_USER_ERROR);
}

echo add(10, 15), '<br />'; //outputs 25
echo add("Hello", "World"), '<br />'; //outputs Hello World

Approche orientée objet incluant la surcharge de méthode:

La surcharge en PHP permet de "créer" dynamiquement des propriétés et des méthodes. Ces entités dynamiques sont traitées via des méthodes magiques que l’on peut établir dans une classe pour divers types d’actions.

Réf.: Http://php.net/manual/en/language.oop5.overloading.php

En PHP, des moyens de surcharge , vous pouvez ajouter des membres de l' objet à l' exécution, en mettant en œuvre certaines des méthodes magiques comme __set, __get, __calletc.

class Foo {

    public function __call($method, $args) {

        if ($method === 'findSum') {
            echo 'Sum is calculated to ' . $this->_getSum($args);
        } else {
            echo "Called method $method";
        }
    }

    private function _getSum($args) {
        $sum = 0;
        foreach ($args as $arg) {
            $sum += $arg;
        }
        return $sum;
    }

}

$foo = new Foo;
$foo->bar1(); // Called method bar1
$foo->bar2(); // Called method bar2
$foo->findSum(10, 50, 30); //Sum is calculated to 90
$foo->findSum(10.75, 101); //Sum is calculated to 111.75

29
La seconde partie de ce que PHP appelle "surcharge" n'est pas si semblable. C'est juste que PHP utilise un nom bien établi pour quelque chose de principalement différent, étant donné que c'est PHP, ce n'est pas surprenant.
Phant0m

10
Ce n'est pas une surcharge de fonction. Pour surcharger réellement une fonction, écrivez maintenant l’équivalent php de findSum(10, "steve", { 86, "2012-09-20" });. Une véritable surcharge autoriserait de nouveaux paramètres de types différents.
Joel Etherton

3
@JoelEtherton - L'interprétation de "surcharge" par PHP est différente de la plupart des langages orientés objet. La surcharge offre généralement la possibilité d’avoir plusieurs méthodes portant le même nom mais différentes quantités et types d’arguments. ref: http://php.net/manual/en/language.oop5.overloading.php La surcharge en PHP permet de "créer" dynamiquement des propriétés et des méthodes. Ces entités dynamiques sont traitées via des méthodes magiques que l’on peut établir dans une classe pour divers types d’actions.
rajukoyilandy

7
@rajukoyilandy: C'est très bien, mais la question de OP demande pourquoi PHP n'implémente pas la surcharge "traditionnelle". Votre réponse ne répond pas à cela.
Joel Etherton

7
Ce n'est pas surcharger. Il n'y a toujours qu'une seule définition / déclaration de la fonction. Ce serait équivalent à va_list / va_arg en C ++. Pouvez-vous résoudre certains des mêmes problèmes? Oui. Mais ce n'est toujours pas surcharger.
Luc

13

Pas une prise en charge complète "Surcharge traditionnelle", seulement partielle .

Une DEFINITION : "Surcharge traditionnelle" permet, lors de l' appel d'une méthode, de disposer de plusieurs méthodes portant le même nom mais avec différentes quantités et types d'arguments. Pour la déclaration de méthode , il est possible d'exprimer une déclaration séparée / isolée pour chaque fonction surchargée.

Remarque: la deuxième partie de cette définition est généralement associée à des langages de programmation à typage statique qui effectuent une vérification de type et / ou une vérification d'arité afin de choisir la déclaration correcte. PHP n'est pas un langage à typage statique, il est dynamique et utilise un typage faible .


SUPPORT PHP :

  • YES, permet d’ appeler plusieurs méthodes portant le même nom mais avec des quantités différentes . Voir func_get_args et réponse @rajukoyilandy, nous pouvons utiliser f(x)et f(x,y).

  • YES, permet d' appeler plusieurs méthodes portant le même nom mais de types différents . Se utilisation interne de gettype dans la méthode.

    • MAIS pour les références ... Seules les variables peuvent être passées par référence, vous ne pouvez pas gérer une surcharge pour la détection constante / variable.
  • NOT permet de déclarer plusieurs méthodes portant le même nom mais avec des quantités différentes . C'est parce que nous pouvons appeler f(x)et f(x,y)avec la même fdéclaration.

  • NOT permet de déclarer plusieurs méthodes portant le même nom mais de types différents . C'est parce que le compilateur PHP doit interpréter f($integer,$string) comme la même fonction que f($string,$integer).

Voir aussi la documentation sur la surcharge PHP5 pour des explications sur la "surcharge non traditionnelle".

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.