Frage Wann benutze ich selbst über $ das?


In PHP 5, was ist der Unterschied zwischen der Verwendung? self und $this?

Wann ist jedes geeignet?


1775
2017-09-30 06:23


Ursprung


Antworten:


Kurze Antwort

Benutzen $this auf den Strom beziehen   Objekt. Benutzen self auf das beziehen   aktuelle Klasse. Mit anderen Worten, verwenden Sie    $this->member für nicht statische Mitglieder,   benutzen self::$member für statische Mitglieder.

Vollständige Antwort

Hier ist ein Beispiel von richtig Benutzung von $this und self für nicht statische und statische Membervariablen:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo $this->non_static_member . ' '
           . self::$static_member;
    }
}

new X();
?>

Hier ist ein Beispiel von falsch Benutzung von $this und self für nicht statische und statische Membervariablen:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo self::$non_static_member . ' '
           . $this->static_member;
    }
}

new X();
?>

Hier ist ein Beispiel von Polymorphismus mit $this für Mitgliedsfunktionen:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        $this->foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

Hier ist ein Beispiel von polymorphes Verhalten unterdrücken durch die Nutzung self für Mitgliedsfunktionen:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        self::foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

Die Idee ist das $this->foo() ruft die foo() Elementfunktion von was> ist der genaue Typ des aktuellen Objekts. Wenn das Objekt ist type Xso ruft es an X::foo(). Wenn das Objekt ist type Y, es ruft Y::foo(). Aber mit> self :: foo (), X::foo() wird immer angerufen.

Von http://www.phpbuilder.com/board/showthread.php?t=10354489:

Durch http://board.phpbuilder.com/member.php?145249-laserlicht


1508
2017-09-30 06:29



Das Schlüsselwort self NICHT beziehen Sie sich nur auf die 'aktuelle Klasse', zumindest nicht in einer Weise, die Sie auf statische Mitglieder beschränkt. Im Kontext eines nicht statischen Mitglieds self bietet auch eine Möglichkeit, die VTable (siehe Wiki auf vtable) für das aktuelle Objekt. So wie du es gebrauchen kannst parent::methodName() die Elternversion einer Funktion aufrufen, damit Sie anrufen können self::methodName() Um die aktuelle Klassenimplementierung einer Methode aufzurufen.

class Person {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }

    public function getTitle() {
        return $this->getName()." the person";
    }

    public function sayHello() {
        echo "Hello, I'm ".$this->getTitle()."<br/>";
    }

    public function sayGoodbye() {
        echo "Goodbye from ".self::getTitle()."<br/>";
    }
}

class Geek extends Person {
    public function __construct($name) {
        parent::__construct($name);
    }

    public function getTitle() {
        return $this->getName()." the geek";
    }
}

$geekObj = new Geek("Ludwig");
$geekObj->sayHello();
$geekObj->sayGoodbye();

Dies wird ausgeben:

Hallo, ich bin Ludwig der Aussenseiter
     Auf Wiedersehen von Ludwig der Person

sayHello() nutzt die $this Zeiger, so dass die Vtable zum Aufruf aufgerufen wird Geek::getTitle(). sayGoodbye() Verwendet self::getTitle(), also wird die vtable nicht verwendet, und Person::getTitle() wird genannt. In beiden Fällen haben wir es mit der Methode eines instanziierten Objekts zu tun und haben Zugriff auf das $this Zeiger innerhalb der aufgerufenen Funktionen.


710
2017-07-27 18:00



VERWENDE NICHT self::, benutzen static::

Es gibt noch einen anderen Aspekt des Selbst: das ist erwähnenswert. Ärgerlich self:: bezieht sich auf den Umfang zum Zeitpunkt der Definition nicht zum Zeitpunkt der Ausführung. Betrachten Sie diese einfache Klasse mit zwei Methoden:

class Person
{

    public static function status()
    {
        self::getStatus();
    }

    protected static function getStatus()
    {
        echo "Person is alive";
    }

}

Wenn wir anrufen Person::status() wir werden sehen "Person lebt". Überlegen Sie nun, was passiert, wenn wir eine Klasse erstellen, die davon erbt:

class Deceased extends Person
{

    protected static function getStatus()
    {
        echo "Person is deceased";
    }

}

Berufung Deceased::status() wir würden erwarten zu sehen, "Person ist verstorben", aber was wir sehen, ist "Person lebt", da der Geltungsbereich die ursprüngliche Methodendefinition beim Aufruf enthält self::getStatus() wurde definiert.

PHP 5.3 hat eine Lösung. das static:: Der Auflösungsoperator implementiert "späte statische Bindung", was eine phantastische Art zu sagen ist, dass er an den Geltungsbereich der aufgerufenen Klasse gebunden ist. Ändern Sie die Zeile in status() zu static::getStatus() und die Ergebnisse sind, was Sie erwarten würden. In älteren Versionen von PHP müssen Sie dafür einen Kludn finden.

Sehen PHP-Dokumentation

Also um die Frage zu beantworten, nicht wie gefragt ...

$this-> bezieht sich auf das aktuelle Objekt (eine Instanz einer Klasse), wohingegen static::bezieht sich auf eine Klasse


428
2017-07-24 15:08



Um wirklich zu verstehen, worüber wir reden, wenn wir darüber reden self gegen $this, wir müssen uns wirklich auf das konzentrieren, was auf einer konzeptionellen und praktischen Ebene vor sich geht. Ich glaube nicht, dass irgendeine der Antworten dies angemessen macht, also hier ist mein Versuch.

Beginnen wir damit, darüber zu reden, was a Klasse und ein Objekt ist.

Klassen und Objekte, konzeptionell

Na und ist ein Klasse? Viele Leute definieren es als Entwurf oder ein Vorlage für ein Objekt. In der Tat können Sie mehr lesen Über Klassen in PHP Hier. Und zu einem gewissen Grad ist es das, was es wirklich ist. Schauen wir uns eine Klasse an:

class Person {
    public $name = 'my name';
    public function sayHello() {
        echo "Hello";
    }
}

Wie Sie sehen können, gibt es eine Eigenschaft für diese Klasse $name und eine Methode (Funktion) aufgerufen sayHello().

Es ist sehr wichtig zu beachten, dass die Klasse ist eine statische Struktur. Was bedeutet, dass die Klasse PersonIst es einmal definiert, ist es immer dasselbe, wo auch immer man es betrachtet.

Ein Objekt auf der anderen Seite ist das, was man anspricht Beispiel einer Klasse. Das heißt, wir nehmen den "Entwurf" der Klasse und erstellen daraus eine dynamische Kopie. Diese Kopie ist jetzt spezifisch mit der Variablen verbunden, in der sie gespeichert ist. Daher werden alle Änderungen an einer Beispiel ist lokal für diese Instanz.

$bob = new Person;
$adam = new Person;
$bob->name = 'Bob';
echo $adam->name; // "my name"

Wir schaffen Neues Instanzen einer Klasse mit dem new Operator.

Daher sagen wir, dass eine Klasse eine globale Struktur und ein Objekt eine lokale Struktur ist. Mach dir keine Sorgen darüber lustig -> Syntax, wir gehen darauf ein wenig ein.

Eine andere Sache, über die wir reden sollten, ist, dass wir es können prüfen Wenn eine Instanz ein instanceof eine bestimmte Klasse: $bob instanceof Person was einen booleschen Wert zurückgibt, wenn der $bob Instanz wurde unter Verwendung der Person Klasse, oder ein Kind von Person.

Zustand definieren

Lasst uns also ein wenig darüber nachdenken, was eine Klasse eigentlich beinhaltet. Es gibt 5 Arten von "Dingen", die eine Klasse enthält:

  1. Eigenschaften - Stellen Sie sich diese als Variablen vor, die jede Instanz enthalten wird.

    class Foo {
        public $bar = 1;
    }
    
  2. Statische Eigenschaften - Stellen Sie sich diese Variablen als Klassen vor, die auf Klassenebene gemeinsam genutzt werden. Das bedeutet, dass sie niemals von jeder Instanz kopiert werden.

    class Foo {
        public static $bar = 1;
    }
    
  3. Methoden - Dies sind Funktionen, die jede Instanz enthalten (und Instanzen bearbeiten).

    class Foo {
        public function bar() {}
    }
    
  4. Statische Methoden - Dies sind Funktionen, die über die gesamte Klasse verteilt sind. Tun sie nicht operiere auf Instanzen, aber nur auf den statischen Eigenschaften.

    class Foo {
        public static function bar() {}
    }
    
  5. Konstanten - Klasse aufgelöste Konstanten. Geht hier nicht tiefer, sondern fügt der Vollständigkeit halber hinzu:

    class Foo {
        const BAR = 1;
    }
    

Im Grunde speichern wir Informationen über den Klassen- und Objektcontainer mit Hilfe von "Hinweisen" statisch welche identifizieren, ob die Information geteilt (und daher statisch) ist oder nicht (und daher dynamisch).

Zustand und Methoden

Innerhalb einer Methode wird die Instanz eines Objekts durch die Methode dargestellt $thisVariable. Der aktuelle Status dieses Objekts ist vorhanden, und das Ändern (Ändern) einer Eigenschaft führt zu einer Änderung an dieser Instanz (aber nicht an anderen).

Wenn eine Methode statisch aufgerufen wird, wird die $this Variable ist nicht definiert. Dies liegt daran, dass mit einem statischen Aufruf keine Instanz verknüpft ist.

Das interessante hier ist, wie statische Aufrufe gemacht werden. Lasst uns darüber reden, wie wir auf den Staat zugreifen:

Zugang zum Staat

Jetzt, wo wir diesen Zustand gespeichert haben, müssen wir darauf zugreifen. Dies kann ein bisschen schwierig werden (oder Weg mehr als ein bisschen), also teilen wir das in zwei Standpunkte: von außerhalb einer Instanz / Klasse (etwa von einem normalen Funktionsaufruf oder vom globalen Bereich) und innerhalb einer Instanz / Klasse (von innerhalb einer Methode auf der Objekt).

Von außerhalb einer Instanz / Klasse

Von außerhalb einer Instanz / Klasse sind unsere Regeln ziemlich einfach und vorhersehbar. Wir haben zwei Operatoren, und jeder sagt uns sofort, ob es sich um eine Instanz oder eine statische Klasse handelt:

  • -> - Objekt-Operator - Dies wird immer verwendet, wenn wir auf eine Instanz zugreifen.

    $bob = new Person;
    echo $bob->name;
    

    Es ist wichtig, diesen Anruf zu beachten Person->foo macht keinen Sinn (seit Person ist eine Klasse, keine Instanz). Daher ist das ein Parse-Fehler.

  • :: - Scope-Auflösung-Operator - Dies wird immer verwendet, um auf eine statische Eigenschaft oder Methode der Klasse zuzugreifen.

    echo Foo::bar()
    

    Außerdem können wir eine statische Methode für ein Objekt auf dieselbe Weise aufrufen:

    echo $foo::bar()
    

    Es ist äußerst wichtig zu beachten, wenn wir das tun von außen, die Instanz des Objekts ist vor der bar() Methode. Das heißt, es ist genau das gleiche wie das Laufen:

    $class = get_class($foo);
    $class::bar();
    

Deshalb, $this ist im statischen Aufruf nicht definiert.

Von innerhalb einer Instanz / Klasse

Die Dinge ändern sich hier ein bisschen. Die gleichen Operatoren werden verwendet, aber ihre Bedeutung wird deutlich verschwommen.

Das Objekt-Operator  -> wird weiterhin verwendet, um Aufrufe an den Instanzstatus des Objekts zu tätigen.

class Foo {
    public $a = 1;
    public function bar() {
        return $this->a;
    }
}

Anrufen der bar() Methode an $foo (eine Instanz von Foo) mit dem Objekt-Operator: $foo->bar() führt zu der Version der Instanz von $a.

So erwarten wir es.

Die Bedeutung des :: Operator obwohl Änderungen. Es hängt vom Kontext des Aufrufs der aktuellen Funktion ab:

  • In einem statischen Kontext

    In einem statischen Kontext werden alle mit :: wird auch statisch sein. Schauen wir uns ein Beispiel an:

    class Foo {
        public function bar() {
            return Foo::baz();
        }
        public function baz() {
            return isset($this);
        }
    }
    

    Berufung Foo::bar() werde den anrufen baz() Methode statisch und daher $this werden nicht bevölkert sein. Es ist erwähnenswert, dass dies in neueren Versionen von PHP (5.3+) dazu führt, dass ein E_STRICT Fehler, weil wir statische Methoden statisch aufrufen.

  • Innerhalb eines Instanzkontexts

    In einem Instanzkontext hingegen werden Aufrufe mit :: abhängig vom Empfänger des Anrufs (die Methode, die wir anrufen). Wenn die Methode definiert ist als static, dann wird ein statischer Aufruf verwendet. Ist dies nicht der Fall, werden die Informationen zur Instanz weitergeleitet.

    Also, Blick auf den obigen Code, anrufend $foo->bar() wird zurückkehren true, da der "statische" Aufruf innerhalb eines Instanzkontextes stattfindet.

Sinn ergeben? Dachte nicht. Es ist verwirrend.

Kürzel Stichwörter

Da es bei der Verwendung von Klassennamen sehr problematisch ist, alle Komponenten zusammenzufassen, bietet PHP drei grundlegende "Verknüpfungs" -Schlüsselwörter, um die Auflösung des Bereichs zu erleichtern.

  • self - Dies bezieht sich auf den aktuellen Klassennamen. Damit self::baz() ist das gleiche wie Foo::baz() innerhalb der Foo Klasse (jede Methode darauf).

  • parent - Dies bezieht sich auf das übergeordnete Element der aktuellen Klasse.

  • static - Dies bezieht sich auf die aufgerufene Klasse. Dank der Vererbung können untergeordnete Klassen Methoden und statische Eigenschaften überschreiben. Also mit ihnen anrufen static Anstelle eines Klassennamens können wir auflösen, woher der Anruf kam und nicht die aktuelle Ebene.

Beispiele

Der einfachste Weg, dies zu verstehen, besteht darin, sich einige Beispiele anzusehen. Lass uns eine Klasse auswählen:

class Person {
    public static $number = 0;
    public $id = 0;
    public function __construct() {
        self::$number++;
        $this->id = self::$number;
    }
    public $name = "";
    public function getName() {
        return $this->name;
    }
    public function getId() {
        return $this->id;
    }
}

class Child extends Person {
    public $age = 0;
    public function __construct($age) {
        $this->age = $age;
        parent::__construct();
    }
    public function getName() {
        return 'child: ' . parent::getName();
    }
}

Wir betrachten hier auch die Erbschaft. Ignorieren Sie für einen Moment, dass dies ein schlechtes Objektmodell ist, aber schauen wir uns an, was passiert, wenn wir damit spielen:

$bob = new Person;
$bob->name = "Bob";
$adam = new Person;
$adam->name = "Adam";
$billy = new Child;
$billy->name = "Billy";
var_dump($bob->getId()); // 1
var_dump($adam->getId()); // 2
var_dump($billy->getId()); // 3

Der ID-Zähler wird also für beide Instanzen und die untergeordneten Elemente gemeinsam verwendet (weil wir ihn verwenden) self um darauf zuzugreifen. Wenn wir gebraucht haben static, könnten wir es in einer Kindklasse überschreiben).

var_dump($bob->getName()); // Bob
var_dump($adam->getName()); // Adam
var_dump($billy->getName()); // child: Billy

Beachten Sie, dass wir das ausführen Person::getName()  Beispiel Methode jedes Mal. Aber wir benutzen das parent::getName() um es in einem der Fälle (der Fall des Kindes) zu tun. Dies macht diesen Ansatz leistungsfähig.

Wort der Vorsicht # 1

Beachten Sie, dass der aufrufende Kontext bestimmt, ob eine Instanz verwendet wird. Deshalb:

class Foo {
    public function isFoo() {
        return $this instanceof Foo;
    }
}

Ist nicht immer wahr.

class Bar {
    public function doSomething() {
        return Foo::isFoo();
    }
}
$b = new Bar;
var_dump($b->doSomething()); // bool(false)

Jetzt ist es Ja wirklich komisch hier. Wir rufen eine andere Klasse an, aber die $this das wird an die übergeben Foo::isFoo() Methode ist die Instanz von $bar.

Dies kann alle Arten von Fehlern und konzeptionellen WTF-Ery verursachen. Also würde ich sehr empfehlen, das zu vermeiden :: Operator von innerhalb der Instanz Methoden auf etwas außer diesen drei virtuellen "short-cut" Keywords (static, self, und parent).

Wort der Vorsicht # 2

Beachten Sie, dass statische Methoden und Eigenschaften von allen Benutzern verwendet werden. Das macht sie im Grunde zu globalen Variablen. Mit den gleichen Problemen, die mit Globals kommen. Ich würde wirklich zögern, Informationen in statischen Methoden / Eigenschaften zu speichern, es sei denn, Sie sind damit vertraut, dass es wirklich global ist.

Wort der Vorsicht # 3

Im Allgemeinen möchten Sie das, was als Late-Static-Binding bekannt ist, verwenden static Anstatt von self. Aber beachte, dass sie nicht dasselbe sind, also sag "immer benutzen static Anstatt von self ist wirklich kurzsichtig. Hören Sie stattdessen auf, über den Aufruf nachzudenken, den Sie ausführen möchten, und überlegen Sie, ob untergeordnete Klassen dies überschreiben können statisch aufgelöst Anruf.

TL / DR

Schade, geh zurück und lies es. Es mag zu lang sein, aber es ist so lange, weil das ein komplexes Thema ist

TL / DR # 2

Ok, gut. Zusamenfassend, self wird verwendet, um zu referenzieren der aktuelle Klassennameinnerhalb einer Klasse, wo $this bezieht sich auf das aktuelle Objekt Beispiel. Beachten Sie, dass self ist eine Kopie / Paste-Abkürzung. Sie können es sicher durch Ihren Klassennamen ersetzen, und es wird gut funktionieren. Aber $this ist eine dynamische Variable, die nicht im Voraus bestimmt werden kann (und möglicherweise nicht einmal Ihre Klasse ist).

TL / DR # 3

Wenn der Objekt-Operator verwendet wird (->), dann Sie immer Ich weiß, dass es sich um eine Instanz handelt. Wenn der Scope-Resolution-Operator verwendet wird (::), benötigen Sie mehr Informationen über den Kontext (sind wir bereits in einem Objekt-Kontext? Sind wir außerhalb eines Objekts? usw.).


228
2018-06-10 15:21



self (nicht $ self) bezieht sich auf die Art der Klasse, wo als $this bezieht sich auf die aktuelle Beispiel der Klasse. self dient zur Verwendung in statischen Elementfunktionen, damit Sie auf statische Elementvariablen zugreifen können. $this wird in nicht statischen Elementfunktionen verwendet und ist eine Referenz auf die Instanz der Klasse, für die die Elementfunktion aufgerufen wurde.

weil this ist ein Objekt, du benutzt es wie: $this->member

weil self ist kein Objekt, es ist im Grunde ein Typ, der sich automatisch auf die aktuelle Klasse bezieht, Sie verwenden es wie folgt: self::member


109
2017-09-30 07:26



$this-> wird verwendet, um auf eine bestimmte Instanz der Variablen einer Klasse (Elementvariablen) oder Methoden zu verweisen.

Example: 
$derek = new Person();

$ derek ist jetzt eine spezifische Instanz von Person. Jede Person hat einen first_name und einen last_name, aber $ derek hat einen spezifischen first_name und last_name (Derek Martin). Innerhalb der $ derek-Instanz können wir auf diese als $ this-> first_name und $ this-> last_name verweisen

ClassName :: bezieht sich auf diesen Typ von Klasse und seine statischen Variablen, statische Methoden. Wenn es hilft, können Sie das Wort "statisch" durch "geteilt" ersetzen. Da sie freigegeben sind, können sie nicht auf $ this verweisen, was sich auf eine bestimmte Instanz bezieht (nicht geteilt). Statische Variablen (d. H. Statische $ db_connection) können unter allen Instanzen eines Objekttyps geteilt werden. Zum Beispiel teilen alle Datenbankobjekte eine einzelne Verbindung (statische $ Verbindung).

Statische Variablen Beispiel: Nehmen wir an, wir haben eine Datenbankklasse mit einer einzigen Membervariable: static $ num_connections; Nun, setze das in den Konstruktor:

function __construct()
{
    if(!isset $num_connections || $num_connections==null)
    {
        $num_connections=0;
    }
    else
    {
        $num_connections++;
    }
}

So wie Objekte Konstruktoren haben, haben sie auch Destruktoren, die ausgeführt werden, wenn das Objekt stirbt oder nicht gesetzt ist:

function __destruct()
{
    $num_connections--;
}

Jedes Mal, wenn wir eine neue Instanz erstellen, erhöht sich unser Verbindungszähler um eins. Jedes Mal, wenn wir eine Instanz zerstören oder nicht mehr verwenden, verringert sich der Verbindungszähler um eins. Auf diese Weise können wir die Anzahl der Instanzen des Datenbankobjekts überwachen, das wir verwenden:

echo DB::num_connections;

Da $ num_connections statisch (shared) ist, spiegelt es die Gesamtzahl der aktiven Datenbankobjekte wider. Möglicherweise haben Sie diese Technik zur gemeinsamen Nutzung von Datenbankverbindungen zwischen allen Instanzen einer Datenbankklasse gesehen. Dies geschieht, da das Erstellen der Datenbankverbindung sehr lange dauert. Daher ist es am besten, nur eine zu erstellen und sie zu teilen (dies wird als Singleton-Muster bezeichnet).

Statische Methoden (d. H. Öffentliche statische View :: format_phone_number ($ digits)) können verwendet werden, OHNE zuerst eines dieser Objekte zu instantiieren (d. H. Sie beziehen sich intern nicht auf $ this).

Statische Methode Beispiel:

public static function prettyName($first_name, $last_name)
{
    echo ucfirst($first_name).' '.ucfirst($last_name);
}

echo Person::prettyName($derek->first_name, $derek->last_name);

Wie Sie sehen können, weiß die öffentliche statische Funktion prettyName nichts über das Objekt. Es funktioniert nur mit den Parametern, die Sie übergeben, wie eine normale Funktion, die nicht Teil eines Objekts ist. Warum sollten wir uns dann darum kümmern, wenn wir es nicht als Teil des Objekts haben könnten?

  1. Erstens hilft das Anhängen von Funktionen an Objekte, die Dinge zu organisieren, sodass Sie wissen, wo Sie sie finden können.
  2. Zweitens verhindert es Namenskonflikte. In einem großen Projekt haben Sie wahrscheinlich zwei Entwickler, die getName () - Funktionen erstellen. Wenn man einen ClassName1 :: getName () erstellt und der andere ClassName2 :: getName () erstellt, ist das überhaupt kein Problem. Kein Konflikt. Yay statische Methoden!

SELBST:: Wenn Sie codieren draußen das Objekt mit der statischen Methode, auf die Sie verweisen möchten, müssen Sie mit dem Objektnamen aufrufen View :: format_phone_number ($ phone_number); Wenn Sie codieren Innerhalb das Objekt, das die statische Methode hat, auf die Sie verweisen möchten, können Sie entweder Verwenden Sie den Namen des Objekts View :: format_phone_number ($ pn) ODER Sie können die Verknüpfung self :: format_phone_number ($ pn) verwenden

Das Gleiche gilt für statische Variablen: Beispiel: View :: templates_path versus self :: templates_path

Wenn wir in der DB-Klasse auf eine statische Methode eines anderen Objekts verweisen würden, würden wir den Namen des Objekts verwenden: Beispiel: Sitzung :: getUsersOnline ();

Aber wenn die DB-Klasse sich auf ihre eigene statische Variable beziehen wollte, würde sie einfach selbst sagen: Beispiel: Selbst :: Verbindung;

Hoffe, dass hilft Dinge zu klären :)


93
2017-10-22 17:52



Von dieser Blogbeitrag:

  • self bezieht sich auf die aktuelle Klasse
  • self kann verwendet werden, um statische Funktionen aufzurufen und statische Elementvariablen zu referenzieren
  • self kann in statischen Funktionen verwendet werden
  • self kann auch polymorphes Verhalten durch Umgehen der vtable ausschalten
  • $this bezieht sich auf das aktuelle Objekt
  • $this kann verwendet werden, um statische Funktionen aufzurufen
  • $this sollte nicht zum Aufrufen statischer Membervariablen verwendet werden. Benutzen self stattdessen.
  • $this kann nicht in statischen Funktionen verwendet werden

27
2018-05-10 12:00