Pourquoi PHP ne supporte-t-il pas 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 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?

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

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".