Explication détaillée de la façon d'utiliser les méthodes magiques PHP

En PHP, les méthodes commençant par deux traits de soulignement __ sont appelées méthodes magiques. Ces méthodes jouent un rôle déterminant en PHP. Les méthodes magiques incluent :

__construct(), constructeur de classe

__destruct(), destructeur de classe

__call(), appelant un objet inaccessible dans l'objet Call

__callStatic() lors de l'appel d'une méthode, appelez

__get() lors de l'appel d'une méthode inaccessible en mode statique, appelez

__set() lors de l'obtention d'une variable membre d'une classe), appelez

__isset() lors de la définition d'une variable membre d'une classe, appelez isset() ou empty() lors de l'appel d'isset() ou empty() sur une propriété inaccessible, appelez

__unset() lors de l'appel d'une propriété inaccessible Appelé lorsque unset() est appelé.

__sleep(), lorsque Serialize() est exécuté, cette fonction sera appelée en premier

__wakeup(), lorsque unserialize() est exécuté, cette fonction

__toString( ), la méthode de réponse lorsque la classe est traitée comme une chaîne

__invoke(), la méthode de réponse lors de l'appel d'un objet en appelant une fonction

__set_state(), lors de l'appel de var_export() à exporter une classe, Cette méthode statique sera appelée.

__clone(), appelé lorsque la copie de l'objet est terminée

__construct() et __destruct()

Le constructeur et le destructeur doivent leur être familiers. quand les objets sont créés et détruits. Par exemple, nous devons ouvrir un fichier, l'ouvrir lorsque l'objet est créé et le fermer lorsque l'objet meurt

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

Ces deux méthodes peuvent être développées en cas d'héritage, par exemple :

.

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

__call() et __callStatic()

seront appelés lors de l'appel d'une méthode inaccessible dans l'objet, cette dernière est une méthode statique. Ces deux méthodes peuvent être utilisées dans les appels de méthodes variables (fonctions variables).

<?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() et __unset()

Ces deux fonctions sont appelées lors de l'obtention/définition des variables membres d'une classe. Par exemple, nous enregistrons les variables d'objet dans un autre tableau au lieu des variables membres de l'objet lui-même

<?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() et __wakeup()

Lorsque nous exécutons Serialize() et Lors de la unserialize(), ces deux fonctions seront appelées en premier. Par exemple, lorsque nous sérialisons un objet, l'objet possède un lien de base de données. Si nous souhaitons restaurer l'état du lien lors de la désérialisation, nous pouvons restaurer le lien en reconstruisant ces deux fonctions. Un exemple est le suivant :

<?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()

La méthode de réponse lorsque l'objet est traité comme une chaîne. Par exemple, utilisez echo $obj; pour générer un objet

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

Cette méthode ne peut renvoyer qu'une chaîne et vous ne pouvez pas lever d'exception dans cette méthode, sinon une erreur fatale se produira.

__invoke()

La méthode de réponse lors de l'appel d'un objet en appelant une fonction. Comme suit

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

__set_state()

Lors de l'appel de var_export() pour exporter une classe, cette méthode statique sera appelée.

<?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()

Appelé lorsque la copie de l'objet est terminée. Par exemple, dans la méthode d'implémentation en mode singleton mentionnée dans l'article Explication détaillée des modèles de conception et implémentation PHP : mode Singleton, cette fonction est utilisée pour empêcher le clonage d'objets.

<?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);
 }
}
?>

Constantes magiques

La plupart des constantes en PHP sont inchangées, mais il y a 8 constantes qui changeront en fonction de l'emplacement du code dans lequel elles se trouvent. sont appelées constantes magiques.

__LINE__, le numéro de ligne actuel dans le fichier

__FILE__, le chemin complet et le nom du fichier

__DIR__, le répertoire où se trouve le fichier

__FUNCTION__, nom de la fonction

__CLASS__, nom de la classe

__TRAIT__, nom du trait

__METHOD__, nom de la méthode de classe

__NAMESPACE__, nom de l'espace de noms actuel

Ces constantes magiques sont souvent utilisées pour obtenir des informations sur l'environnement actuel ou pour enregistrer des journaux.

Ce qui précède représente l’intégralité du contenu de cet article, j’espère qu’il sera utile à l’étude de chacun.

Pour des explications plus détaillées sur l'utilisation des méthodes PHP Magic, veuillez faire attention au site Web PHP chinois !