¿Qué es la sobrecarga y anulación de funciones en php?

Solución:

Sobrecarga está definiendo funciones que tienen firmas similares, pero que tienen diferentes parámetros. Primordial solo es pertinente para las clases derivadas, donde la clase principal ha definido un método y la clase derivada desea anular ese método.

En PHP, solo puede sobrecargar métodos usando el método mágico __call.

Un ejemplo de primordial:

<?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 sobrecarga de funciones se produce cuando define el mismo nombre de función dos veces (o más) utilizando un conjunto de parámetros diferente. Por ejemplo:

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

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

En el ejemplo anterior, la función compute está sobrecargado con dos firmas de parámetros diferentes. * Esto aún no es compatible con PHP. Una alternativa es usar argumentos opcionales:

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

---

La anulación de funciones ocurre cuando se extiende una clase y se reescribe una función que existía en la clase principal:

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

Por ejemplo, compute anula el comportamiento establecido en Addition.

Estrictamente hablando, no hay diferencia, ya que no puedes hacer ninguna de las dos 🙂

La anulación de funciones podría haberse realizado con una extensión de PHP como APD, pero está obsoleta y la última versión de afaik no se podía utilizar.

La sobrecarga de funciones en PHP no se puede realizar debido a la escritura dinámica, es decir, en PHP no “define” las variables para que sean de un tipo en particular. Ejemplo:

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

Cada variable es de un tipo diferente, sin embargo, puede conocer el tipo antes de la ejecución (ver la cuarta). Como comparación, otros idiomas usan:

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

En el último ejemplo, debe establecer con fuerza el tipo de variable (como ejemplo, utilicé el tipo de datos “algo”).

---

Otro “problema” por el que la sobrecarga de funciones no es posible en PHP: PHP tiene una función llamada func_get_args (), que devuelve una matriz de argumentos actuales, ahora considere el siguiente código:

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

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

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

Teniendo en cuenta que ambas funciones aceptan cualquier cantidad de argumentos, ¿cuál debería elegir el compilador?

---

Finalmente, me gustaría señalar por qué las respuestas anteriores son parcialmente incorrectas;
función sobrecarga / anulación NO es igual a método sobrecarga / anulación.

Donde un método es como una función pero específico para una clase, en cuyo caso, PHP permite anular en clases, pero nuevamente sin sobrecarga, debido a la semántica del lenguaje.

Para concluir, lenguajes como Javascript permiten anular (pero nuevamente, no sobrecargar), sin embargo, también pueden mostrar la diferencia entre anular una función de usuario y un método:

/// 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'

---

---

Utiliza Nuestro Buscador