sobrecarga - php__call

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

Question

En PHP, ¿qué quiere decir con sobrecarga de función y anulación de función? y cual es la diferencia entre ambos? No pude entender cuál es la diferencia entre ellos.

Answer 1

Aunque el paradigma de sobrecarga no es totalmente compatible con PHP, se puede lograr el mismo efecto (o muy similar) con los parámetros predeterminados (como alguien mencionó anteriormente).

Si defines tu función de esta manera:

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

Cuando llamas a esta función como:

f();

obtendrá una funcionalidad (n. ° 1), pero si la llama con un parámetro como:

f(1);

obtendrás otra funcionalidad (n. ° 2). Ese es el efecto de la sobrecarga: una funcionalidad diferente según los parámetros de entrada de la función.

Lo sé, alguien se preguntará ahora qué funcionalidad obtendrá si llama a esta función como f (0).

Answer 2

Ejemplo de sobrecarga

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);

Answer 3

Estrictamente hablando, no hay diferencia, ya que no puedes hacer nada :)

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

La sobrecarga de funciones en PHP no se puede realizar debido a la escritura dinámica, es decir, en PHP no se "define" que las variables sean de un tipo 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 (vea el 4to). Como comparación, otros idiomas usan:

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

En el último ejemplo, debe establecer a la fuerza el tipo de la variable (como ejemplo, utilicé el tipo de datos "algo").

Otro "problema" por el cual 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; la sobrecarga / anulación de funciones NO es igual a la sobrecarga / anulación de métodos .

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

Para concluir, los lenguajes como Javascript permiten la anulación (pero, una vez más, no hay sobrecarga), 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''

Answer 4

Existen algunas diferencias entre la sobrecarga y sobrecarga de función, aunque ambas contienen el mismo nombre de función. En la sobrecarga, entre las mismas funciones de nombre se incluyen diferentes tipos de argumentos o tipos de retorno, como: "function add (int a, int b)" & " función add (float a, float b); aquí la función add () está sobrecargada. En el caso de anular, tanto el argumento como el nombre de la función son los mismos. Generalmente se encuentra en herencia o en rasgos. Tenemos que seguir algunas tácticas para introducir , qué función se ejecutará ahora. Por lo tanto, al anular, el programador sigue algunas tácticas para ejecutar la función deseada, donde en la sobrecarga el programa puede identificar automáticamente la función deseada ... ¡Gracias!

Answer 5

La sobrecarga de funciones se produce cuando define el mismo nombre de función dos veces (o más) utilizando diferentes conjuntos de parámetros. Por ejemplo:

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

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

En el ejemplo anterior, el compute la función 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 sobreescritura de funciones ocurre cuando extiende una clase y reescribe una función que existía en la clase padre:

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

Por ejemplo, compute anula el comportamiento establecido en Addition .

Answer 6

Me gustaría señalar aquí que la sobrecarga en PHP tiene un significado completamente diferente en comparación con otros lenguajes de programación. Mucha gente ha dicho que la sobrecarga no es compatible con PHP y con la definición convencional de sobrecarga, sí, que la funcionalidad no está explícitamente disponible.

Sin embargo, la definición correcta de sobrecarga en PHP es completamente diferente.

En PHP, la sobrecarga se refiere a la creación dinámica de propiedades y métodos usando métodos mágicos como __set () y __get (). Estos métodos de sobrecarga se invocan cuando se interactúa con métodos o propiedades que no son accesibles o no están declarados.

Aquí hay un enlace del manual de PHP: http://www.php.net/manual/en/language.oop5.overloading.php

Answer 7

PHP 5.xx no admite sobrecarga, es por eso que PHP no es completamente OOP.

Answer 8

La sobrecarga es definir funciones que tienen firmas similares, pero tienen diferentes parámetros. La anulación solo es pertinente para las clases derivadas, donde la clase padre ha definido un método y la clase derivada desea anular ese método.

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

Un ejemplo de anulación :

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