Ausführliche Erklärung der Verwendung magischer PHP-Methoden

In PHP werden Methoden, die mit zwei Unterstrichen __ beginnen, als magische Methoden bezeichnet. Diese Methoden spielen in PHP eine entscheidende Rolle. Zu den magischen Methoden gehören:

__construct(), Klassenkonstruktor

__destruct(), Klassendestruktor

__call(), Aufruf eines unzugänglichen Objekts im Objekt. Rufen Sie

__callStatic() beim Aufrufen einer Methode, Aufruf

__get() beim Aufrufen einer unzugänglichen Methode im statischen Modus, Aufruf

__set() beim Abrufen einer Mitgliedsvariablen einer Klasse), Aufruf

__isset() beim Festlegen von Mitgliedsvariablen einer Klasse, Aufruf von isset() oder empty() beim Aufrufen unzugänglicher Eigenschaften, Aufruf

__unset() beim Aufrufen unzugänglicher Eigenschaften. Wird aufgerufen, wenn unset() ist angerufen.

__sleep(), wenn serialize() ausgeführt wird, wird diese Funktion zuerst aufgerufen

__wakeup(), wenn unserialize() ausgeführt wird, diese Funktion

__toString( ), die Antwortmethode, wenn die Klasse als Zeichenfolge behandelt wird

__invoke(), die Antwortmethode, wenn ein Objekt durch Aufrufen einer Funktion aufgerufen wird

__set_state(), wenn var_export() aufgerufen wird Exportieren Sie eine Klasse. Diese statische Methode wird aufgerufen.

__clone(), wird aufgerufen, wenn die Objektkopie abgeschlossen ist

__construct() und __destruct()

Der Konstruktor und der Destruktor sollten ihnen bekannt sein wenn Objekte erstellt und zerstört werden. Beispielsweise müssen wir eine Datei öffnen, sie öffnen, wenn das Objekt erstellt wird, und sie schließen, wenn das Objekt stirbt.

<?php 
class FileRead
{
 protected $handle = NULL;
 
 function __construct(){
  $this->handle = fopen(...);
 }
 
 function __destruct(){
  fclose($this->handle);
 }
}
?>

Diese beiden Methoden können bei Vererbung erweitert werden, zum Beispiel:

<?php 
class TmpFileRead extends FileRead
{
 function __construct(){
  parent::__construct();
 }
 
 function __destruct(){
  parent::__destruct();
 }
}
?>

__call() und __callStatic()

werden aufgerufen, wenn eine nicht zugängliche Methode im Objekt aufgerufen wird, letztere ist eine statische Methode. Diese beiden Methoden können in Aufrufen variabler Methoden (Variablenfunktionen) verwendet werden.

<?php
class MethodTest 
{
 public function __call ($name, $arguments) {
  echo "Calling object method &#39;$name&#39; ". implode(&#39;, &#39;, $arguments). "\n";
 }
 
 public static function __callStatic ($name, $arguments) {
  echo "Calling static method &#39;$name&#39; ". implode(&#39;, &#39;, $arguments). "\n";
 }
}
 
$obj = new MethodTest;
$obj->runTest(&#39;in object context&#39;);
MethodTest::runTest(&#39;in static context&#39;);
?>

__get(), __set(), __isset() und __unset()

Diese beiden Funktionen werden aufgerufen, wenn Mitgliedsvariablen einer Klasse abgerufen/festgelegt werden. Beispielsweise speichern wir die Objektvariablen in einem anderen Array anstelle der Mitgliedsvariablen des Objekts selbst

<?php 
class MethodTest
{
 private $data = array();
 
 public function __set($name, $value){
  $this->data[$name] = $value;
 }
 
 public function __get($name){
  if(array_key_exists($name, $this->data))
   return $this->data[$name];
  return NULL;
 }
 
 public function __isset($name){
  return isset($this->data[$name])
 }
 
 public function unset($name){
  unset($this->data[$name]);
 }
}
?>

__sleep() und __wakeup()

Wenn wir serialize() und ausführen Bei unserialize() werden diese beiden Funktionen zuerst aufgerufen. Wenn wir beispielsweise ein Objekt serialisieren, verfügt das Objekt über eine Datenbankverknüpfung. Wenn wir den Verknüpfungsstatus während der Deserialisierung wiederherstellen möchten, können wir die Verknüpfung wiederherstellen, indem wir diese beiden Funktionen wiederherstellen. Ein Beispiel lautet wie folgt:

<?php
class Connection 
{
 protected $link;
 private $server, $username, $password, $db;
 
 public function __construct($server, $username, $password, $db)
 {
  $this->server = $server;
  $this->username = $username;
  $this->password = $password;
  $this->db = $db;
  $this->connect();
 }
 
 private function connect()
 {
  $this->link = mysql_connect($this->server, $this->username, $this->password);
  mysql_select_db($this->db, $this->link);
 }
 
 public function __sleep()
 {
  return array(&#39;server&#39;, &#39;username&#39;, &#39;password&#39;, &#39;db&#39;);
 }
 
 public function __wakeup()
 {
  $this->connect();
 }
}
?>

__toString()

Die Antwortmethode, wenn das Objekt als Zeichenfolge behandelt wird. Verwenden Sie beispielsweise echo $obj;, um ein Objekt

<?php
// Declare a simple class
class TestClass
{
 public function __toString() {
  return &#39;this is a object&#39;;
 }
}
 
$class = new TestClass();
echo $class;
?>

auszugeben. Diese Methode kann nur eine Zeichenfolge zurückgeben, und Sie können in dieser Methode keine Ausnahme auslösen, da sonst ein schwerwiegender Fehler auftritt.

__invoke()

Die Antwortmethode beim Aufrufen eines Objekts durch Aufrufen einer Funktion. Wie folgt

<?php
class CallableClass 
{
 function __invoke() {
  echo &#39;this is a object&#39;;
 }
}
$obj = new CallableClass;
var_dump(is_callable($obj));
?>

__set_state()

Wenn Sie var_export() zum Exportieren einer Klasse aufrufen, wird diese statische Methode aufgerufen.

<?php
class A
{
 public $var1;
 public $var2;
 
 public static function __set_state ($an_array) {
  $obj = new A;
  $obj->var1 = $an_array[&#39;var1&#39;];
  $obj->var2 = $an_array[&#39;var2&#39;];
  return $obj;
 }
}
 
$a = new A;
$a->var1 = 5;
$a->var2 = &#39;foo&#39;;
var_dump(var_export($a));
?>

__clone()

Wird aufgerufen, wenn die Objektkopie abgeschlossen ist. Beispielsweise wird diese Funktion in der Singleton-Modus-Implementierungsmethode, die im Artikel Detaillierte Erläuterung von Entwurfsmustern und PHP-Implementierung: Singleton-Modus erwähnt wird, verwendet, um zu verhindern, dass Objekte geklont werden.

<?php 
public class Singleton {
 private static $_instance = NULL;
 
 // 私有构造方法 
 private function __construct() {}
 
 public static function getInstance() {
  if (is_null(self::$_instance)) {
   self::$_instance = new Singleton();
  }
  return self::$_instance;
 }
 
 // 防止克隆实例
 public function __clone(){
  die(&#39;Clone is not allowed.&#39; . E_USER_ERROR);
 }
}
?>

Magische Konstanten

Die meisten Konstanten in PHP bleiben unverändert, aber es gibt 8 Konstanten, die sich je nach Speicherort des Codes, in dem sie sich befinden, ändern werden magische Konstanten genannt.

__LINE__, die aktuelle Zeilennummer in der Datei

__FILE__, der vollständige Pfad und Dateiname der Datei

__DIR__, das Verzeichnis, in dem sich die Datei befindet

__FUNCTION__, Funktionsname

__CLASS__, Klassenname

__TRAIT__, Merkmalsname

__METHOD__, Klassenmethodenname

__NAMESPACE__, Name des aktuellen Namespace

Diese magischen Konstanten werden häufig verwendet, um aktuelle Umgebungsinformationen abzurufen oder Protokolle aufzuzeichnen.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, er wird für das Studium aller hilfreich sein.

Ausführlichere Erklärungen zur Verwendung der PHP Magic-Methoden finden Sie auf der chinesischen PHP-Website!