Qu'est-ce que la surcharge de fonctions et la surcharge de fonctions en php ?

Question

En PHP, qu'entendez-vous par surcharge de fonction et surcharge de fonction, et quelle est la différence entre les deux ? Je n'ai pas réussi à comprendre quelle est la différence entre les deux.

Answer 1

Surcharge de travail consiste à définir des fonctions qui ont des signatures similaires, mais dont les paramètres sont différents. Remplacement de n'est pertinente que pour les classes dérivées, lorsque la classe mère a défini une méthode et que la classe dérivée souhaite contourner cette méthode.

En PHP, vous ne pouvez surcharger les méthodes qu'en utilisant la méthode magique __call .

Un exemple de Remplacement de :

<?php

class Foo {
   function myFoo() {
      return "Foo";
   }
}

class Bar extends Foo {
   function myFoo() {
      return "Bar";
   }
}

$foo = new Foo;
$bar = new Bar;
echo($foo->myFoo()); //"Foo"
echo($bar->myFoo()); //"Bar"
?>

Answer 2

La surcharge de fonctions se produit lorsque vous définissez le même nom de fonction deux fois (ou plus) en utilisant un ensemble différent de paramètres. Par exemple :

class Addition {
  function compute($first, $second) {
    return $first+$second;
  }

  function compute($first, $second, $third) {
    return $first+$second+$third;
  }
}

Dans l'exemple ci-dessus, la fonction compute est surchargé avec deux signatures de paramètres différentes. *Ceci n'est pas encore supporté par PHP. Une alternative est d'utiliser des arguments optionnels :

class Addition {
  function compute($first, $second, $third = 0) {
    return $first+$second+$third;
  }
}

---

La substitution de fonction se produit lorsque vous étendez une classe et réécrivez une fonction qui existait dans la classe parente :

class Substraction extends Addition {
  function compute($first, $second, $third = 0) {
    return $first-$second-$third;
  }
}

Par exemple, compute remplace le comportement défini dans Addition .

Answer 3

Strictement parlant, il n'y a pas de différence, puisque vous ne pouvez faire ni l'un ni l'autre :)

Le remplacement des fonctions aurait pu être fait avec une extension PHP comme APD, mais elle est dépréciée et, à ma connaissance, la dernière version était inutilisable.

La surcharge des fonctions en PHP ne peut pas être faite à cause du typage dynamique, c'est-à-dire qu'en PHP, vous ne pouvez pas "définir" les variables comme étant d'un type particulier. Exemple :

$a=1;
$a='1';
$a=true;
$a=doSomething();

Chaque variable est d'un type différent, mais vous pouvez connaître le type avant l'exécution (voir la 4ème). A titre de comparaison, d'autres langages utilisent :

int a=1;
String s="1";
bool a=true;
something a=doSomething();

Dans le dernier exemple, vous devez définir de force le type de la variable (à titre d'exemple, j'ai utilisé le type de données "quelque chose").

---

Un autre "problème" est que la surcharge de fonctions n'est pas possible en PHP : PHP a une fonction appelée func_get_args(), qui renvoie un tableau d'arguments courants, maintenant considérez le code suivant :

function hello($a){
  print_r(func_get_args());
}

function hello($a,$a){
  print_r(func_get_args());
}

hello('a');
hello('a','b');

Considérant que les deux fonctions acceptent n'importe quel nombre d'arguments, laquelle le compilateur doit-il choisir ?

---

Enfin, j'aimerais souligner pourquoi les réponses ci-dessus sont partiellement fausses ; fonction surcharge/surcharge n'est PAS égal à méthode surcharge/surcharge.

Une méthode est comme une fonction mais spécifique à une classe, dans ce cas, PHP autorise la surcharge dans les classes, mais pas la surcharge, en raison de la sémantique du langage.

Pour conclure, des langages comme Javascript permettent la surcharge (mais encore une fois, pas de surcharge), mais ils peuvent aussi montrer la différence entre la surcharge d'une fonction utilisateur et d'une méthode :

/// Function Overriding ///

function a(){
   alert('a');
}
a=function(){
   alert('b');
}

a(); // shows popup with 'b'

/// Method Overriding ///

var a={
  "a":function(){
    alert('a');
  }
}
a.a=function(){
   alert('b');
}

a.a(); // shows popup with 'b'

Answer 4

Bien que le paradigme de surcharge ne soit pas entièrement supporté par PHP, le même effet (ou un effet très similaire) peut être obtenu avec des paramètres par défaut (comme quelqu'un l'a déjà mentionné).

Si vous définissez votre fonction comme ceci :

function f($p=0)
{
  if($p)
  {
    //implement functionality #1 here
  }
  else
  {
    //implement functionality #2 here
  }
}

Lorsque vous appelez cette fonction comme :

f();

vous obtiendrez une seule fonctionnalité (#1), mais si vous l'appelez avec un paramètre comme :

f(1);

vous obtiendrez une autre fonctionnalité (#2). C'est l'effet de la surcharge - une fonctionnalité différente selon le(s) paramètre(s) d'entrée de la fonction.

Je sais, quelqu'un va demander maintenant quelle fonctionnalité on va obtenir si on appelle cette fonction comme f(0).

Answer 5

PHP 5.x.x ne supporte pas la surcharge, c'est pourquoi PHP n'est pas complètement OOP.