Warum unterstützt PHP keine Funktionsüberladung?

Ich frage mich, ob eines der Hauptmerkmale einer Programmiersprache die Fähigkeit ist, Funktionen über Argumente zu überladen. Ich denke, dass es im Kontext der objektorientierten Programmierung wesentlich ist.

Wird es absichtlich zurückgelassen und ist es nicht erlaubt? Oder ist Überladen keine gute Praxis?

Wer hat dir gesagt, dass PHP das Überladen von Funktionen nicht unterstützt? !!!

Tatsächlich unterstützt PHP das Überladen von Funktionen, jedoch auf andere Weise. Die Überladungsfunktionen von PHP unterscheiden sich von denen von Java:

PHP interpretiert "Überladung" anders als die meisten objektorientierten Sprachen. Überladen bietet traditionell die Möglichkeit, mehrere Methoden mit demselben Namen, aber unterschiedlichen Mengen und Arten von Argumenten zu verwenden.

Überprüfen Sie die folgenden Codeblöcke.

Funktion zur Ermittlung der Summe von n Zahlen:

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

Funktion zum Hinzufügen von zwei Zahlen oder zum Verketten von zwei Zeichenfolgen:

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

Objektorientierter Ansatz einschließlich Methodenüberladung:

Überladen in PHP bietet die Möglichkeit, Eigenschaften und Methoden dynamisch "zu erstellen". Diese dynamischen Entitäten werden mit magischen Methoden verarbeitet, die in einer Klasse für verschiedene Aktionstypen festgelegt werden können.

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

In PHP, Überlastung Mittel Sie Objektelemente zur Laufzeit hinzufügen können, um einige der magischen Methoden wie Implementierung __set, __get, __callusw.

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

Keine vollständige Unterstützung für "traditionelles Überladen", nur teilweise .

A DEFINITION : "Traditional Overloading" bietet beim Aufruf von method die Möglichkeit, mehrere Methoden mit demselben Namen, aber unterschiedlichen Mengen und Arten von Argumenten zu verwenden. Für Verfahren Erklärung bietet es die Möglichkeit , eine separate / isolierte Erklärung für jede überladene Funktion zum Ausdruck bringen.

Hinweis: Der zweite Teil dieser Definition bezieht sich normalerweise auf statisch typisierte Programmiersprachen, die eine Typprüfung und / oder eine Aritätsprüfung durchführen , um die richtige Deklaration auszuwählen. PHP ist keine statisch typisierte Sprache, es ist dynamisch und verwendet schwache Typisierung .

PHP UNTERSTÜTZUNG :

• JA, bietet die Möglichkeit, mehrere Methoden mit demselben Namen, aber unterschiedlichen Mengen aufzurufen . Siehe func_get_args und @rajukoyilandy Antwort, wir können und verwenden .f(x)f(x,y)

• JA, bietet die Möglichkeit, mehrere Methoden mit demselben Namen, aber unterschiedlichen Typen aufzurufen . Siehe interne Verwendung von gettype in der Methode.

  • ABER für Referenzen ... Nur Variablen können als Referenz übergeben werden, Sie können keine Überladung für die Konstanten- / Variablenerkennung verwalten.

• NOT bietet die Möglichkeit , mehrere Methoden mit demselben Namen, aber unterschiedlichen Mengen zu deklarieren . Dies liegt daran, dass wir f(x)und f(x,y)mit der gleichen fErklärung anrufen können .

• NOT bietet die Möglichkeit , mehrere Methoden mit demselben Namen, aber unterschiedlichen Typen zu deklarieren . Dies liegt daran, dass der PHP-Compiler f($integer,$string) dieselbe Funktion wie diese interpretieren muss f($string,$integer).

In der Dokumentation zum Überladen von PHP5 finden Sie Erklärungen zum "nicht-traditionellen Überladen".