Introduction and use of php magic methods and magic constants

Some things are easy to forget if you don’t use them often, such as magic methods and magic constants.

Magic methods

In PHP, methods starting with two underscores __ are called magic methods. These methods play a pivotal role in PHP. Magic methods include:

__construct(), class constructor

__destruct(), class destructor

__call(), when calling an inaccessible method in an object, call

__callStatic() in a static way When calling an inaccessible method, call

__get(), when obtaining a member variable of a class, call

__set(), when setting a member variable of a class, call

__isset(), when calling isset() on an inaccessible property ) or empty(), is called when unset() is called on an inaccessible property.

__sleep(), when executing serialize(), this function will be called first

__wakeup(), when unserialize() is executed, this function will be called first

__toString(), the response method when the class is treated as a string

__invoke(), the response method when calling an object by calling a function

__set_state(), this static method will be called when var_export() is called to export a class.

__clone(), called when the object copy is completed

__construct() and __destruct()

The constructor and destructor should be familiar, they are called when the object is created and destroyed. For example, we need to open a file, open it when the object is created, and close it when the object dies

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

These two methods can be extended when inheriting, for example:

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

__call() and __callStatic()

These two methods are called when an inaccessible method is called in the object, and the latter is a static method. These two methods may be used in variable method (Variable functions) calls.

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

These two functions are called when getting/set member variables of a class. For example, we save the object variables in another array instead of the member variables of the object itself

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

When we execute serialize() and unserialize(), they will be called first these two functions. For example, when we serialize an object, the object has a database link. If we want to restore the link state during deserialization, we can restore the link by reconstructing these two functions. An example is as follows:

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

The response method when the object is treated as a string. For example, use echo $obj; to output an object

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

This method can only return a string, and an exception cannot be thrown in this method, otherwise a fatal error will occur.

__invoke()

The response method when calling an object by calling a function. As follows

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

__set_state()

When calling var_export() to export a class, this static method will be called.

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

is called when the object copy is completed. For example, in the singleton mode implementation method mentioned in the article Detailed Explanation of Design Patterns and PHP Implementation: Singleton Mode, this function is used to prevent objects from being cloned.

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

Magic constants

Most of the constants in PHP are unchanged, but there are 8 constants that change with the location of the code where they are located. These 8 constants are called magic constants.

__LINE__, the current line number in the file

__FILE__, the full path and file name of the file

__DIR__, the directory where the file is located

__FUNCTION__, the function name

__CLASS__, the name of the class

__TRAIT__, the name of the Trait

__METHOD__, the method name of the class

__NAMESPACE__, the name of the current namespace

These magic constants are often used to obtain current environment information or record logs.