Por que o PHP não suporta sobrecarga de funções?

Gostaria de saber se um dos principais recursos de uma linguagem de programação é ter a capacidade de sobrecarregar funções por meio de argumentos. Eu acho que é essencial no contexto da programação orientada a objetos.

É intencionalmente deixado para trás e não é permitido? Ou sobrecarregar não é uma boa prática?

Quem disse que o PHP não suporta sobrecarga de funções? !!!

Na verdade, o PHP suporta sobrecarga de funções, mas de uma maneira diferente. Os recursos de sobrecarga do PHP são diferentes dos de Java:

A interpretação do PHP de "sobrecarga" é diferente da maioria das linguagens orientadas a objetos. Tradicionalmente, a sobrecarga fornece a capacidade de ter vários métodos com o mesmo nome, mas com quantidades e tipos diferentes de argumentos.

Faça o check-out dos seguintes blocos de código.

Função para encontrar a soma dos n números:

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

Função para adicionar dois números ou concatenar duas cadeias:

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

Abordagem Orientada a Objetos, incluindo Sobrecarga de Método:

A sobrecarga no PHP fornece meios para "criar" dinamicamente propriedades e métodos. Essas entidades dinâmicas são processadas por métodos mágicos que podem ser estabelecidos em uma classe para vários tipos de ação.

Ref: http://php.net/manual/en/language.oop5.overloading.php

Em PHP, sobrecarregando significa que você pode adicionar membros de objetos em tempo de execução, através da implementação de alguns dos métodos mágicos como __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

Não é um suporte completo à "Sobrecarga tradicional", apenas parcial .

UMA DEFINIÇÃO : "Sobrecarga tradicional" fornece, ao chamar o método, a capacidade de ter vários métodos com o mesmo nome, mas com quantidades e tipos diferentes de argumentos. Para declaração de método , fornece a opção de expressar uma declaração separada / isolada para cada função sobrecarregada.

Nota: a segunda parte desta definição é geralmente associada a linguagens de programação com estaticamente que fazem verificação de tipo e / ou verificação de arity , para escolher a declaração correta. O PHP não é uma linguagem estaticamente digitada, é dinâmica e usa digitação fraca .

SUPORTE PHP :

• SIM, fornece a capacidade de chamar vários métodos com o mesmo nome, mas com quantidades diferentes . Veja func_get_args e resposta @rajukoyilandy, podemos usar f(x)e f(x,y).

• SIM, fornece a capacidade de chamar vários métodos com o mesmo nome, mas com tipos diferentes . Veja o uso interno do gettype no método.

  • MAS para referências ... Somente variáveis ​​podem ser passadas por referência, você não pode gerenciar uma sobrecarga para detecção constante / variável.

• NÃO fornece a capacidade de declarar vários métodos com o mesmo nome, mas com quantidades diferentes . Isso ocorre porque podemos ligar f(x)e f(x,y)com a mesma fdeclaração.

• NÃO fornece a capacidade de declarar vários métodos com o mesmo nome, mas com tipos diferentes . Isso ocorre porque o compilador PHP deve interpretar f($integer,$string) como a mesma função que f($string,$integer).

Veja também a documentação de sobrecarga do PHP5 para obter as explicações sobre "sobrecarga não tradicional".