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

37

Eu estou querendo saber se uma das principais características de uma linguagem de programação é ter a capacidade de sobrecarregar funções via 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?

    
por user1179459 20.09.2012 / 06:21
fonte

2 respostas

33

Quem disse que o PHP não suporta a 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 do Java:

PHP's interpretation of "overloading" is different than most object oriented languages. Overloading traditionally provides the ability to have multiple methods with the same name but different quantities and types of arguments.

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

Função para encontrar a soma de 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 para concatenar duas strings:

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:

Overloading in PHP provides means to dynamically "create" properties and methods. These dynamic entities are processed via magic methods one can establish in a class for various action types.

Ref: link

No PHP, a sobrecarga significa que você pode adicionar membros do objeto em tempo de execução, implementando alguns dos métodos mágicos como __set , __get , __call etc.

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
    
por 20.09.2012 / 09:36
fonte
11

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

A DEFINITION: "Traditional Overloading" provides, when calling method, the ability to have multiple methods with the same name but different quantities and types of arguments. For method declaration, it provides the option to express a separate/isolated declaration for each overloaded function.

Nota: a segunda parte desta definição é geralmente associada a linguagens de programação com tipagem estática que fazem verificação de tipo e / ou verificação de aridade , para escolher a declaração correta. PHP não é uma linguagem estaticamente tipada, é dinâmica , e usa qual digitação .

SUPORTE AO PHP :

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

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

    • MAS para referências ... Apenas variáveis podem ser passadas por referência, você não pode gerenciar uma sobrecarga para detecção de constante / variável.
  • NOT fornece a capacidade de declarar vários métodos com o mesmo nome, mas quantidades diferentes . Isso ocorre porque podemos chamar f(x) e f(x,y) com a mesma declaração f .

  • NOT fornece a capacidade de declarar vários métodos com o mesmo nome, mas 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 documentação de sobrecarga do PHP5 para as explicações sobre "sobrecarga não-tradicional".

    
por 14.03.2013 / 15:06
fonte