it-swarm.com.de

Warum PHP unterstützt keine Funktionsüberladung?

Ich frage mich, ob eines der Hauptmerkmale einer Programmiersprache darin besteht, Funktionen über Argumente überladen zu können. Ich denke, es ist wesentlich im Kontext der objektorientierten Programmierung.

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

38
user1179459

Wer hat dir gesagt PHP unterstützt keine Funktionsüberladung? !!!

Eigentlich PHP unterstützt das Überladen von Funktionen, aber auf andere Weise. PHPs Überladungsfunktionen unterscheiden sich von Java:

PHPs Interpretation von "Überladung" unterscheidet sich von den meisten objektorientierten Sprachen. Das Ü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 zum Ermitteln 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:

Das Überladen in PHP bietet Mittel zum dynamischen "Erstellen" von Eigenschaften und Methoden. Diese dynamischen Entitäten werden über magische Methoden verarbeitet, die in einer Klasse für verschiedene Aktionstypen eingerichtet werden können.

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

In PHP bedeutet Überladen, dass Sie zur Laufzeit Objektelemente hinzufügen können, indem Sie einige der magischen Methoden wie __set, __get, __call usw.

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
34
rajukoyilandy

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

EINE DEFINITION : "Traditionelles Überladen" bietet beim Aufruf Methode die Möglichkeit, mehrere Methoden mit demselben Namen zu haben aber unterschiedliche Mengen und Arten von Argumenten. Für die Methode Deklaration Bietet sie die Möglichkeit, für jede überladene Funktion eine separate/isolierte Deklaration auszudrücken.

Hinweis: Der zweite Teil dieser Definition ist normalerweise mit statisch typisierten Programmiersprachen verknüpft, die Typprüfungen und/oder Aritätsprüfungen durchführen, um die richtige Deklaration auszuwählen. PHP ist keine statisch typisierte Sprache, es ist dynamisch und verwende 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 f(x) und f(x,y) verwenden.

  • JA, bietet die Möglichkeit, mehrere Methoden mit demselben Namen, aber verschiedenen 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 derselben f -Deklaration aufrufen können.

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

Siehe auch Dokumentation zum Überladen von PHP5 für die Erklärungen zum "nicht traditionellen Überladen".

15
Peter Krauss