Que sont les méthodes magiques et les constantes magiques en php

En PHP, les méthodes magiques font référence aux méthodes commençant par deux traits de soulignement "__", telles que "__call()", "__get()", "__set()", etc. ; cela sera 8 constantes qui changent avec le changement de leur emplacement de code, comme "__LINE__", "__FILE__", etc.

L'environnement d'exploitation de ce tutoriel : système windows7, version PHP7.1, ordinateur DELL G3

Méthode magique (Méthodes magiques)

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 central en PHP. Les méthodes magiques incluent :

• __construct(), constructeur de classe
• __destruct(), destructeur de classe
• __call(), appelé dans un objet Call
• __callStatic() lorsqu'une méthode inaccessible est appelée, appeler
• __get() lors de l'appel d'une méthode inaccessible en mode statique, appeler
• , appelé lors de la définition des variables membres d'une classe, __set()
• , appelé lorsque __isset() ou isset() est appelé sur des propriétés inaccessibles, appelé empty()
• , lorsqu'il est appelé sur des propriétés inaccessibles Appelé lorsqu'une propriété inaccessible est appelée __unset(). unset()
• , lors de l'exécution de __sleep(), cette fonction sera appelée en premier serialize()
• , lorsque __wakeup() sera exécutée, cette fonction unserialize()
, la méthode de réponse lorsque la classe est traitée comme une chaîne
• __toString()
, la méthode de réponse lors de l'appel d'un objet en appelant une fonction
• __invoke()
, lors de l'appel de
• pour exporter une classe, Cette méthode statique sera appelée. __set_state()var_export()
, les constructeurs et destructeurs
• __clone()

et __construct()__destruct() sont appelés lorsque la copie de l'objet est terminée Il devrait être familier qu'ils soient appelés lorsque des 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();
    }
}
?>

<. 🎜>

et

__call()__callStatic()Ces deux méthodes seront appelées lorsqu'une méthode inaccessible est appelée dans l'objet, et 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). Ces deux fonctions sont appelées lors de l'obtention/définition des variables membres d'une classe. Par exemple, nous enregistrons les variables de l'objet dans un autre tableau au lieu des variables membres de l'objet lui-même

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

et

__get()__set() lorsque nous exécutons __isset() et __unset(), 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 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()La méthode de réponse lorsque l'objet est traité comme une chaîne. Par exemple, utilisez __wakeup() pour générer un objet

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

Cette méthode ne peut renvoyer qu'une chaîne, et une exception ne peut pas être levée dans cette méthode, sinon une erreur fatale se produira.

serialize()unserialize()

__toString()La méthode de réponse lors de l'appel d'un objet en appelant une fonction. Cette méthode statique sera appelée lorsque

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

$class = new TestClass();
echo $class;
?>

echo $obj;

est appelée comme suit.

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

__invoke()

Appelé lorsque la copie de l'objet est terminée. Par exemple, dans l'article

Explication détaillée du modèle de conception et implémentation PHP : modèle singleton, la méthode d'implémentation du modèle singleton est mentionnée. Cette fonction est utilisée pour empêcher le clonage des objets. __set_state()

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

Constantes magiques

var_export()

La plupart des constantes en PHP sont inchangées, mais il y a 8 constantes qui changent avec leur emplacement Ces 8 constantes changent en fonction de emplacement du code. Ces 8 constantes sont appelées constantes magiques.

__clone(), le numéro de ligne actuel dans le fichier

, le chemin complet et le nom du fichier

, le répertoire où se trouve le fichier

, nom de la fonction

, nom de la classe
• __LINE__
, nom du trait
• __FILE__
, nom de classe Le nom de la méthode
• __DIR__
, le nom de l'espace de noms actuel
• __FUNCTION__
, ces constantes magiques sont souvent utilisées pour obtenir des informations sur l'environnement actuel ou enregistrer des journaux.
• __CLASS__Apprentissage recommandé : "
Tutoriel vidéo PHP
• "__TRAIT__

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!