web-dev-qa-db-fra.com

Pourquoi PHP ne prend pas en charge la surcharge de fonctions?

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

Est-il intentionnellement laissé de côté et interdit? Ou la surcharge n'est-elle pas une bonne pratique?

phpmethod-overloading
38
user1179459

Qui vous a dit PHP ne prend pas en charge la surcharge de fonctions? !!!

En fait PHP supporte la surcharge de fonctions, mais d'une manière différente. PHP's fonctionnalités de surcharge sont différents de Java:

L'interprétation PHP de la "surcharge" est différente de la plupart des langages orientés objet. La surcharge offre traditionnellement la possibilité d'avoir plusieurs méthodes avec le même nom mais différentes quantités et types d'arguments.

Extraire 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 permettant d'ajouter deux nombres ou de 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, y compris la surcharge de méthode:

La surcharge en PHP fournit des moyens 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 différents types d'actions.

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

En PHP, la surcharge signifie que vous pouvez ajouter des membres d'objet au moment de l'exécution, en implémentant certaines des méthodes magiques comme __set, __get, __call etc.

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
34
rajukoyilandy

Pas un support complet de "surcharge traditionnelle", seulement partiel .

UNE DÉFINITION : "Surcharge traditionnelle" fournit, lorsque appelle la méthode , la possibilité d'avoir plusieurs méthodes avec le même nom mais des quantités et des types d'arguments différents. Pour la déclaration de méthode , il offre la possibilité 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 aux langages de programmation typés statiquement qui vérifient le type et/ou vérifient l'arité , pour choisir la bonne déclaration. PHP n'est pas un langage de type statique, il est dynamique , et utilisez typage faible .

SUPPORT PHP :

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

  • OUI, offre la possibilité d'appeler plusieurs méthodes avec le même nom mais différents types . Voir l'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 offre la possibilité de déclarer plusieurs méthodes avec le même nom mais des quantités différentes . C'est parce que nous pouvons appeler f(x) et f(x,y) avec la même déclaration f.

  • NOT offre la possibilité de déclarer plusieurs méthodes avec le même nom mais différents types . En effet, le compilateur PHP doit interpréter f($integer,$string) comme la même fonction que f($string,$integer).

Voir aussi documentation de surcharge PHP5 pour les explications de "surcharge non traditionnelle".

15
Peter Krauss