Perché PHP non supporta il sovraccarico delle funzioni?

Mi chiedo se una delle caratteristiche chiave di un linguaggio di programmazione sia la capacità di sovraccaricare le funzioni tramite argomenti. Penso che sia essenziale nel contesto della programmazione orientata agli oggetti.

È intenzionalmente lasciato alle spalle e non è permesso? O il sovraccarico non è una buona pratica?

Chi ti ha detto che PHP non supporta il sovraccarico delle funzioni? !!!

In realtà PHP supporta il sovraccarico delle funzioni, ma in modo diverso. Le funzionalità di sovraccarico di PHP sono diverse da quelle di Java:

L'interpretazione di PHP del "sovraccarico" è diversa dalla maggior parte dei linguaggi orientati agli oggetti. Il sovraccarico offre tradizionalmente la possibilità di avere più metodi con lo stesso nome ma con quantità e tipi di argomenti diversi.

Verifica i seguenti blocchi di codice.

Funzione per trovare la somma di n numeri:

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

Funzione per aggiungere due numeri o concatenare due stringhe:

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

Approccio orientato agli oggetti incluso il sovraccarico del metodo:

Il sovraccarico in PHP fornisce mezzi per "creare" dinamicamente proprietà e metodi. Queste entità dinamiche vengono elaborate tramite metodi magici che si possono stabilire in una classe per vari tipi di azioni.

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

In PHP, mezzi sovraccarico è possibile aggiungere i membri di oggetto a run-time, mediante l'attuazione di alcuni dei metodi magici come __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

Non è un supporto completo "Sovraccarico tradizionale", solo parziale .

UNA DEFINIZIONE : "Sovraccarico tradizionale" fornisce, quando si chiama il metodo, la possibilità di avere più metodi con lo stesso nome ma con quantità e tipi di argomenti diversi. Per la dichiarazione del metodo , offre la possibilità di esprimere una dichiarazione separata / isolata per ciascuna funzione sovraccaricata.

Nota: la seconda parte di questa definizione è solitamente associata a linguaggi di programmazione tipicamente statici che effettuano il controllo del tipo e / o il controllo dell'arity , per scegliere la dichiarazione corretta. PHP non è un linguaggio tipicamente statico, è dinamico e usa una digitazione debole .

SUPPORTO PHP :

• SÌ, offre la possibilità di chiamare più metodi con lo stesso nome ma con quantità diverse . Vedi func_get_args e la risposta di @rajukoyilandy, possiamo usare f(x)e f(x,y).

• SÌ, offre la possibilità di chiamare più metodi con lo stesso nome ma tipi diversi . Se uso interno di gettype nel metodo.

  • MA per riferimenti ... Solo le variabili possono essere passate per riferimento, non è possibile gestire un sovraccarico per il rilevamento costante / variabile.

• NON offre la possibilità di dichiarare più metodi con lo stesso nome ma con quantità diverse . Questo perché possiamo chiamare f(x)e f(x,y)con la stessa fdichiarazione.

• NON offre la possibilità di dichiarare più metodi con lo stesso nome ma tipi diversi . Questo perché il compilatore PHP deve interpretare f($integer,$string) come la stessa funzione che f($string,$integer).

Vedere anche la documentazione di sovraccarico PHP5 per le spiegazioni "sovraccarico non tradizionale".