Introduction and use of PHP magic methods and Magic constants

Some things, if not used frequently, can easily be forgotten, such as magic methods and magic constants.

Magic Method (Magic methods)

PHP's method of starting with two underscores is called a magic method, which plays a pivotal role in PHP. Magic methods include:

__construct (), constructor of class

__destruct (), Destructor for class

__call (), called when an inaccessible method is called in an object

__callstatic (), called when a non-accessible method is called in a static manner

__get (), which is called when a member variable of a class is obtained

__set (), which is called when a member variable of a class is set

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

__unset () is called when unset () is called on a non-accessible property.

__sleep (), when executing serialize (), this function is called first

__wakeup (), when executing unserialize (), this function is called first

__tostring (), which is a method of responding when a class is treated as a string

__invoke (), called when a function is called in a way that responds to an object

__set_state (), this static method is called when the Var_export () export class is called.

__clone (), called when the object copy is complete

__construct () and __destruct ()

Constructors and destructors should be unfamiliar, and they are called when objects are created and extinct. For example, we need to open a file, open when the object is created, close when the object dies

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

These two methods can be extended during inheritance, for example:

<?phpclass 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 an object, which is a static method. These two methods may be used in the variable method (Variable functions) call.

<?phpclass methodtest{public    function __call ($name, $arguments) {        echo "calling object method ' $name '". Implode (', ', $arguments). "\ n";    }     public static function __callstatic ($name, $arguments) {        echo "calling static method ' $name '". Implode (', ', $arguments). "\ n";    }} $obj = new Methodtest; $obj->runtest (' in object context '); Methodtest::runtest (' in static context ');? >

__get (), __set (), __isset () and __unset ()

These two functions are called when get/set a member variable of a class. For example, we save an object variable in another array, not the member variable of the object itself.

<?phpclass 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 (), these two functions are called first. For example, when we serialize an object that has a database link that wants to restore the link state in deserialization, you can refactor the two functions to achieve a link recovery. Examples are as follows:

<?phpclass 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 (' Server ', ' username ', ' password ', ' db ');    }     Public Function __wakeup ()    {        $this->connect ();    }}? >

_tostring ()

The method that the object responds to as a string. For example, use echo $obj to output an object

<?php//Declare A simple classclass testclass{public    function __tostring () {        return ' This is a object ';    } } $class = new TestClass (); Echo $class;? >

This method can only return a string, and cannot throw an exception in this method, or a fatal error will occur.

__invoke ()

A method of responding when invoking an object in a way called a function. As follows

<?phpclass callableclass{    function __invoke () {        echo ' This is a object ';    }} $obj = new Callableclass;var_dump (is_callable ($obj));? >

__set_state ()

This static method is called when the Var_export () export class is called.

<?phpclass a{public    $var 1;    Public $var 2;     public static function __set_state ($an _array) {        $obj = new A;        $obj->var1 = $an _array[' var1 ');        $obj->var2 = $an _array[' var2 ');        return $obj;    }} $a = new A; $a->var1 = 5; $a->var2 = ' foo '; Var_dump (Var_export ($a));? >

__clone ()

Called when the object copy is complete. For example, in the design pattern in detail and the implementation of PHP: Singleton mode in the article mentioned in the implementation of the Singleton mode, using this function to prevent the object from being cloned.

<?phppublic class Singleton {    private static $_instance = NULL;     Private constructor Method    __construct () {} public     static function getinstance () {        if (Is_null (self::$_ Instance) {            self::$_instance = new Singleton ();        }        return self::$_instance;    }     Prevents the clone instance public    function __clone () {die        (' clone was not allowed. '). E_user_error);}    }? >

Magic constant (Magic constants)

The constants in PHP are mostly constant, but there are 8 constants that change as their code positions change, and these 8 constants are called Magic constants.

__line__, the current line number in the file

__file__, the full path and filename of the file

__dir__, the directory where the files are located

__function__, Function name

__class__, the name of the class

__trait__,trait's name.

__method__, method name of the class

__namespace__, the name of the current namespace

These Magic constants are often used to obtain current environmental information or log records.

