Warum unterstützt PHP keine Funktionsüberladung?

37

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?

user1179459
quelle
27
Funktionsüberladung ist nicht wirklich ein Merkmal der OO-Programmierung. Unterklasse Funktion über Reiten zum Zweck des Polymorphismus ist in der Regel ein notwendiges Merkmal von OO betrachtet - aber nicht Überladen von Funktionen auf Basis von Argumenten. Python hat auch keine argumentbasierte Funktionsüberladung. In statisch typisierten Sprachen, in denen die Funktionsbindung zur Kompilierungszeit stattfindet und auf dem Typ jedes Funktionsparameters basiert, ist eine Funktionsüberladung wahrscheinlich praktischer.
Charles Salvia
2
@CharlesSalvia Das wäre eine gute Antwort.
Kiamlaluno
1
Was er sagte. Außerdem wird die Funktionsüberlastung überbewertet. Sie müssen nicht denselben Funktionsnamen für verschiedene Funktionen verwenden. Geben Sie Ihren Funktionen nur Namen, die ähnlich, aber nicht identisch sind. Bedienerüberladung auf der anderen Seite ...
Mr Lister
Obwohl ich keine Antwort auf die spezifische Frage habe, werde ich diesen Link posten , der mir ein besseres Verständnis für die Verwendung von Überladung in PHP verschafft hat. hoffe, es hilft
DiegoDD

Antworten:

33

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
Rajukoyilandy
quelle
29
Das zweite bisschen über das, was PHP "Überladen" nennt, ist gar nicht so ähnlich. Es ist nur PHP, das einen gut eingeführten Namen für etwas verwendet, das größtenteils anders ist.
Phant0m
10
Das ist keine Funktionsüberlastung. Um eine Funktion wirklich zu überladen, schreiben Sie jetzt das PHP-Äquivalent von findSum(10, "steve", { 86, "2012-09-20" });. Eine echte Überlastung würde neue Parameter unterschiedlicher Art ermöglichen.
Joel Etherton
3
@JoelEtherton - 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. ref: http://php.net/manual/en/language.oop5.overloading.php Ü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.
Rajukoyilandy
7
@rajukoyilandy: Das ist alles schön und gut, aber in der Frage von OP wird gefragt, warum PHP kein "traditionelles" Überladen implementiert. Ihre Antwort spricht das nicht an.
Joel Etherton
7
Dies ist keine Überlastung. Es gibt nur noch eine Definition / Deklaration der Funktion. Dies wäre äquivalent zu va_list / va_arg in C ++. Können Sie einige der gleichen Probleme lösen? Ja. Aber es ist immer noch nicht überladen.
Luke
13

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".

Peter Krauss
quelle