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

En PHP, qu'entendez-vous par surcharge de fonction et remplacement de fonction. et quelle est la différence entre les deux? ne pouvait pas comprendre quelle est la différence entre eux.

La surcharge définit des fonctions qui ont des signatures similaires, mais qui ont des paramètres différents. Le remplacement n'est pertinent que pour les classes dérivées, où la classe parente a défini une méthode et la classe dérivée souhaite remplacer cette méthode.

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

Un exemple de remplacement :

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

La surcharge de fonction se produit lorsque vous définissez le même nom de fonction deux fois (ou plus) en utilisant un ensemble de paramètres différent. 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 computeest surchargée avec deux signatures de paramètres différentes. * Ceci n'est pas encore pris en charge en PHP. Une alternative consiste à utiliser des arguments optionnels:

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

Le remplacement de fonction se produit lorsque vous étendez une classe et réécrivez une fonction qui existait dans la classe parent:

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

Par exemple, computeremplace le comportement défini dans Addition.

À proprement parler, il n'y a pas de différence, puisque vous ne pouvez pas faire non plus :)

Le remplacement de fonction aurait pu être fait avec une extension PHP comme APD, mais il est obsolète et la dernière version afaik était inutilisable.

La surcharge de fonctions en PHP ne peut pas être effectuée à cause du typage dynamique, c'est-à-dire qu'en PHP vous ne "définissez" pas les variables comme étant 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 4e). A titre de comparaison, d'autres langues utilisent:

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

Dans le dernier exemple, vous devez forcer le type de la variable (par exemple, j'ai utilisé le type de données "quelque chose").

Un autre "problème" pour lequel la surcharge de fonction n'est pas possible en PHP: PHP a une fonction appelée func_get_args (), qui retourne un tableau d'arguments courants, considérons maintenant 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');

Étant donné que les deux fonctions acceptent n'importe quelle quantité d'arguments, lequel doit choisir le compilateur?

Enfin, je voudrais souligner pourquoi les réponses ci-dessus sont partiellement fausses; la surcharge / substitution de fonction n'est PAS égale à la surcharge / substitution de méthode .

Lorsqu'une méthode est comme une fonction mais spécifique à une classe, auquel cas, PHP permet de surcharger dans les classes, mais encore une fois pas de surcharge, en raison de la sémantique du langage.

Pour conclure, des langages comme Javascript autorisent le remplacement (mais encore une fois, pas de surcharge), mais ils peuvent également montrer la différence entre le remplacement d'une fonction utilisateur et 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'

Exemple de surcharge

class overload {
    public $name;
    public function __construct($agr) {
        $this->name = $agr;
    }
    public function __call($methodname, $agrument) {
         if($methodname == 'sum2') {

          if(count($agrument) == 2) {
              $this->sum($agrument[0], $agrument[1]);
          }
          if(count($agrument) == 3) {

              echo $this->sum1($agrument[0], $agrument[1], $agrument[2]);
          }
        }
    }
    public function sum($a, $b) {
        return $a + $b;
    }
    public function sum1($a,$b,$c) {

        return $a + $b + $c;
    }
}
$object = new overload('Sum');
echo $object->sum2(1,2,3);

Bien que le paradigme de surcharge ne soit pas entièrement pris en charge par PHP, le même effet (ou très similaire) peut être obtenu avec le ou les paramètres par défaut (comme quelqu'un l'a mentionné précédemment).

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 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 - des fonctionnalités différentes selon les paramètres d'entrée de la fonction.

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

Je tiens à souligner ici que la surcharge en PHP a une signification complètement différente par rapport aux autres langages de programmation. Beaucoup de gens ont dit que la surcharge n'est pas prise en charge en PHP et par la définition conventionnelle de la surcharge, oui, cette fonctionnalité n'est pas explicitement disponible.

Cependant, la définition correcte de la surcharge en PHP est complètement différente.

En PHP, la surcharge fait référence à la création dynamique de propriétés et de méthodes à l'aide de méthodes magiques telles que __set () et __get (). Ces méthodes de surcharge sont appelées lors de l'interaction avec des méthodes ou des propriétés qui ne sont pas accessibles ou non déclarées.

Voici un lien du manuel PHP: http://www.php.net/manual/en/language.oop5.overloading.php

La surcharge de méthode se produit lorsque deux méthodes ou plus avec le même nom de méthode mais un nombre différent de paramètres dans une seule classe. PHP ne prend pas en charge la surcharge de méthode. La substitution de méthode signifie que deux méthodes avec le même nom de méthode et le même nombre de paramètres dans deux classes différentes signifie la classe parent et la classe enfant.

Il y a quelques différences entre la surcharge de fonction et le remplacement, bien que les deux contiennent le même nom de fonction. En surcharge, les fonctions de même nom contiennent un type d'argument ou un type de retour différent; comme: "function add (int a, int b)" & " function add (float a, float b); Ici, la fonction add () est surchargée. En cas de substitution, l'argument et le nom de la fonction sont identiques.Il se trouve généralement dans l'héritage ou dans les traits.Nous devons suivre certaines tactiques pour introduire , quelle fonction sera exécutée maintenant. Donc, en écrasant le programmeur suit quelques tactiques pour exécuter la fonction désirée où dans la surcharge le programme peut identifier automatiquement la fonction désirée ... Merci!

Surcharge: Dans le monde réel, la surcharge signifie attribuer des choses supplémentaires à quelqu'un. Comme dans le monde réel, la surcharge en PHP signifie appeler des fonctions supplémentaires. D'une autre manière, vous pouvez dire qu'il a une fonction plus mince avec des paramètres différents.En PHP, vous pouvez utiliser la surcharge avec des fonctions magiques, par exemple __get, __set, __call etc.

Exemple de surcharge:

class Shape {
   const Pi = 3.142 ;  // constant value
  function __call($functionname, $argument){
    if($functionname == 'area')
    switch(count($argument)){
        case 0 : return 0 ;
        case 1 : return self::Pi * $argument[0] ; // 3.14 * 5
        case 2 : return $argument[0] * $argument[1];  // 5 * 10
    }

  }

 }
 $circle = new Shape();`enter code here`
 echo "Area of circle:".$circle->area()."</br>"; // display the area of circle Output 0
 echo "Area of circle:".$circle->area(5)."</br>"; // display the area of circle
 $rect = new Shape();
 echo "Area of rectangle:".$rect->area(5,10); // display area of rectangle

Remplacement: dans la programmation orientée objet, le remplacement consiste à remplacer la méthode parente dans la classe enfant.En cas de remplacement, vous pouvez re-déclarer la méthode de la classe parent dans la classe enfant. Donc, fondamentalement, le but de la substitution est de changer le comportement de votre méthode de classe parente.

Exemple de remplacement:

class parent_class
{

  public function text()    //text() is a parent class method
  {
    echo "Hello!! everyone I am parent class text method"."</br>";
  }
  public function test()   
  {
    echo "Hello!! I am second method of parent class"."</br>";
  }

}

class child extends parent_class
{
  public function text()     // Text() parent class method which is override by child 
  class
  {
    echo "Hello!! Everyone i am child class";
  }

 }

 $obj= new parent_class();
 $obj->text();            // display the parent class method echo
 $obj= new parent_class();
 $obj->test();
 $obj= new child();
 $obj->text(); // display the child class method echo

PHP 5.xx ne prend pas en charge la surcharge, c'est pourquoi PHP n'est pas entièrement en POO.