Was Sie über __construct() und __destory() in PHP beachten sollten

Grundsätzlich verfügen alle Programmiersprachen über die Konzepte von Konstruktoren und Destruktoren in Klassen. Der Konstruktor kann verwendet werden, um einige Initialisierungsarbeiten durchzuführen, wenn eine Funktionsinstanz erstellt wird, während der Destruktor einige Aufräumarbeiten durchführen kann, bevor die Instanz zerstört wird. Relativ gesehen verwenden wir häufig Konstruktoren, während Destruktoren im Allgemeinen zum Freigeben von Ressourcen wie Datenbankverknüpfungen, Lese- und Schreibhandles für Dateien usw. verwendet werden.

Die Verwendung von Konstruktoren und Destruktoren

Sehen wir uns zunächst die Verwendung normaler Konstruktoren und Destruktoren an:

class A
{
    public $name;
    public function __construct($name)
    {
        $this->name = $name;
        echo "A：构造函数被调用，{$this->name}", PHP_EOL;
    }
    public function __destruct()
    {
        echo "A：析构函数被调用，{$this->name}", PHP_EOL;
    }
}
$a = new A('$a');
echo '-----', PHP_EOL;
class B extends A
{
    public function __construct($name)
    {
        $this->name = $name;
        parent::__construct($name);
        echo "B：构造函数被调用，{$this->name}", PHP_EOL;
    }
    public function __destruct()
    {
        parent::__destruct();
        echo "B：析构函数被调用，{$this->name}", PHP_EOL;
    }
}
class C extends A
{
    public function __construct($name)
    {
        $this->name = $name;
        echo "C：构造函数被调用，{$this->name}", PHP_EOL;
    }
    public function __destruct()
    {
        echo "C：析构函数被调用，{$this->name}", PHP_EOL;
    }
}
class D extends A
{
}
// unset($a); // $a的析构提前
// $a = null; // $a的析构提前
$b = new B('$b');
$c = new C('$c');
$d = new D('$d');
echo '-----', PHP_EOL;exit;
// A：构造函数被调用，$a
// -----
// A：构造函数被调用，$b
// B：构造函数被调用，$b
// C：构造函数被调用，$c
// A：构造函数被调用，$d
// -----
// A：析构函数被调用，$d
// C：析构函数被调用，$c
// A：析构函数被调用，$b
// B：析构函数被调用，$b
// A：析构函数被调用，$a

Oben ist da etwas drin Code, der sich von dem unterscheidet, was wir erwartet haben? Es ist in Ordnung, schauen wir es uns einzeln an:

Wenn eine Unterklasse den Konstruktor oder Destruktor der übergeordneten Klasse überschreibt und der Konstruktor der übergeordneten Klasse nicht explizit mit parent::__constuct() aufgerufen wird, dann Die übergeordnete Klasse wird nicht ausgeführt. Wenn beispielsweise eine C-Unterklasse den Konstruktor oder Destruktor nicht überschreibt, wird standardmäßig der Destruktor der übergeordneten Klasse aufgerufen Wenn unset() verwendet wird, wird es aufgerufen, nachdem die Skriptausführung abgeschlossen ist. Die Aufrufreihenfolge im Testcode ähnelt dem Stapel, der zuerst reingeht und zuletzt rausgeht (C->B->A, C wird zuerst zerstört). , aber in der Serverumgebung ist dies nicht unbedingt der Fall. Das heißt, die Reihenfolge ist nicht unbedingt festgelegt

Referenzproblem des Destruktors

Wenn Objekte gegenseitig enthalten Verweise auf sich selbst, Sie möchten es auf NULL setzen oder unset( ) kann beim Aufruf des Destruktors Probleme verursachen.

class E
{
    public $name;
    public $obj;
    public function __destruct()
    {
        echo "E：析构函数被调用，" . $this->name, PHP_EOL;
        echo '-----', PHP_EOL;
    }
}
$e1 = new E();
$e1->name = 'e1';
$e2 = new E();
$e2->name = 'e2';
$e1->obj = $e2;
$e2->obj = $e1;

Ähnlich wie in diesem Code sind $e1 und $e2 beide Objekte der Klasse E und enthalten jeweils Verweise aufeinander. Vereinfacht ausgedrückt treten ähnliche Probleme auf, wenn Sie über eigene Referenzen verfügen.

$e1 = new E();
$e1->name = 'e1';
$e2 = new E();
$e2->name = 'e2';
$e1->obj = $e2;
$e2->obj = $e1;
$e1 = null;
$e2 = null;
// gc_collect_cycles();
$e3 = new E();
$e3->name = 'e3';
$e4 = new E();
$e4->name = 'e4';
$e3->obj = $e4;
$e4->obj = $e3;
$e3 = null;
$e4 = null;
echo 'E destory', PHP_EOL;

Wenn wir den Kommentar in der Zeile gc_collect_cycles() nicht aktivieren, ist die Reihenfolge, in der der Destruktor ausgeführt wird, wie folgt:

// 不使用gc回收的结果
// E destory
// E：析构函数被调用，e1
// -----
// E：析构函数被调用，e2
// -----
// E：析构函数被调用，e3
// -----
// E：析构函数被调用，e4
// -----

Wenn wir den Kommentar in der Zeile gc_collect_cycles( aktivieren) ), Die Ausführungsreihenfolge des Destruktors lautet:

// 使用gc回收后结果
// E：析构函数被调用，e1
// -----
// E：析构函数被调用，e2
// -----
// E destory
// E：析构函数被调用，e3
// -----
// E：析构函数被调用，e4
// -----

Es ist ersichtlich, dass PHP einmal mit gc recycelt werden muss und der Destruktor der Klasse erst ausgeführt wird, wenn alle Verweise auf das Objekt freigegeben sind. Wenn die Referenz nicht freigegeben wird, wird der Destruktor nicht ausgeführt.

Kompatibilitätsprobleme mit Konstruktoren niedriger Versionen

Vor PHP5 war der Konstruktor von PHP eine Methode mit demselben Namen wie der Klassenname. Das heißt, wenn ich eine Klasse F habe, dann ist die Methode der Funktion F(){} ihr Konstruktor. Um mit niedrigeren Versionen kompatibel zu sein, behält PHP diese Funktion weiterhin bei. Wenn es eine Methode mit demselben Namen wie der Klassenname gibt, wird eine Timeout-Warnung gemeldet, die sich jedoch nicht auf die Programmausführung auswirkt.

class F
{
    public function f() 
    {
        // Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; F has a deprecated constructor 
        echo "F：这也是构造函数，与类同名，不区分大小写", PHP_EOL;
    }
    // function F(){
    //     // Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; F has a deprecated constructor 
    //     echo "F：这也是构造函数，与类同名", PHP_EOL;
    // }
    // function __construct(){
    //     echo "F：这是构造函数，__construct()", PHP_EOL;
    // }
}
$f = new F();

Wenn __construc() und eine Klassenmethode mit demselben Namen gleichzeitig existieren, wird __construct() zuerst verwendet. Beachten Sie außerdem, dass bei Funktionsnamen die Groß-/Kleinschreibung nicht beachtet wird, sodass die Methoden F() und f() identisch sind und zu Konstruktoren werden. Ebenso können f() und F() nicht gleichzeitig existieren, da die Groß-/Kleinschreibung nicht beachtet wird. Natürlich empfehlen wir nicht, eine Funktion mit demselben Namen als Konstruktor zu verwenden. Schließlich handelt es sich um eine veraltete Funktion, die möglicherweise eines Tages eingestellt wird.

Konstruktorüberladung

PHP führt keine Methodenüberladung aus, d. h. Unterklassen überschreiben Methoden der übergeordneten Klasse, können jedoch nicht mehrere Methoden definieren Gleicher Name, aber unterschiedliche Parameter. In Sprachen wie Java ist das Überladen von Methoden sehr praktisch, insbesondere beim Instanziieren einer Klasse, um polymorphe Funktionen einfach zu implementieren.

$r1 = new R(); // 默认构造函数
$r2 = new R('arg1'); // 默认构造函数 一个参数的构造函数重载，arg1
$r3 = new R('arg1', 'arg2'); // 默认构造函数 两个参数的构造函数重载，arg1，arg2

Wenn Sie versuchen, mehrere __construct() zu definieren, teilt PHP Ihnen genau wie im obigen Code direkt mit, dass es nicht ausgeführt werden kann. Gibt es also eine andere Möglichkeit, die Funktion des obigen Codes zu erreichen? Natürlich gibt es das, sonst würden wir es nicht schreiben.

class R
{
    private $a;
    private $b;
    public function __construct()
    {
        echo '默认构造函数', PHP_EOL;
        $argNums = func_num_args();
        $args = func_get_args();
        if ($argNums == 1) {
            $this->constructA(...$args);
        } elseif ($argNums == 2) {
            $this->constructB(...$args);
        }
    }
    public function constructA($a)
    {
        echo '一个参数的构造函数重载，' . $a, PHP_EOL;
        $this->a = $a;
    }
    public function constructB($a, $b)
    {
        echo '两个参数的构造函数重载，' . $a . '，' . $b, PHP_EOL;
        $this->a = $a;
        $this->b = $b;
    }
}
$r1 = new R(); // 默认构造函数
$r2 = new R('arg1'); // 默认构造函数 一个参数的构造函数重载，arg1
$r3 = new R('arg1', 'arg2'); // 默认构造函数 两个参数的构造函数重载，arg1，arg2

Es ist relativ problematischer als Sprachen wie Java, erreicht aber die gleiche Funktion.

Zugriffsbeschränkungen für Konstruktoren und Destruktoren

Konstruktoren und Destruktoren sind standardmäßig öffentlich und haben dieselben Standardwerte wie andere Methoden in der Klasse. Natürlich können sie auch auf privat und geschützt eingestellt werden. Wenn Sie den Konstruktor nicht öffentlich machen, können Sie die Klasse nicht instanziieren. Dies wird häufig im Singleton-Modus verwendet. Schauen wir uns den Code eines Singleton-Modus direkt an.

class Singleton
{
    private static $instance;
    public static function getInstance()
    {
        return self::$instance == null ? self::$instance = new Singleton() : self::$instance;
    }
    private function __construct()
    {
    }
}
$s1 = Singleton::getInstance();
$s2 = Singleton::getInstance();
echo $s1 === $s2 ? 's1 === s2' : 's1 !== s2', PHP_EOL;
// $s3 = new Singleton(); // Fatal error: Uncaught Error: Call to private Singleton::__construct() from invalid context

Wenn $s3 instanziiert werden möchte, wird direkt ein Fehler gemeldet. Bezüglich der Frage, warum das Singleton-Muster eine externe Instanziierung unmöglich macht, können wir einen Blick auf das Singleton-Muster im vorherigen Artikel zum Designmustersystem werfen.

Zusammenfassung

Ich hätte nicht erwartet, dass der Konstruktor, den wir jeden Tag verwenden, so viele Tricks haben kann. Was bei der täglichen Entwicklung beachtet werden muss, ist die Vererbung von Unterklassen Das Problem ist das Aufrufproblem des Konstruktors der übergeordneten Klasse, wenn der Konstruktor neu geschrieben wird, und das Zerstörungsproblem, wenn die Referenz erstellt wird.

Empfohlenes Tutorial: „PHP-Tutorial“

Das obige ist der detaillierte Inhalt vonWas Sie über __construct() und __destory() in PHP beachten sollten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!