What are magic methods and magic constants in php

In PHP, magic methods refer to methods starting with two underscores "__", such as "__call()", "__get()", "__set()", etc.; magic constants refer to methods that will 8 constants that change with the change of their code location, such as "__LINE__", "__FILE__", etc.

The operating environment of this tutorial: windows7 system, PHP7.1 version, DELL G3 computer

Magic method (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 the object, call
• __callStatic(), when calling an inaccessible method in static mode Call
• __get(), call
• __set() when obtaining a member variable of a class, call # when setting a member variable of a class
• ##__isset(), called when isset() or empty() is called on an inaccessible property
• __unset(), called when unset() is called on an inaccessible property.
• __sleep(), when executing serialize(), this function will be called first
• __wakeup(), executed unserialize(), 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(), when calling var_export() when exporting a class, this static method will be called.
• __clone(), when the object copy is completed, call

##__construct() and __destruct() Constructors and destructors should be familiar, they are called when objects are 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 expanded 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]);
    }
}
?>

and__wakeup()When we execute serialize()

unserialize(), these two functions will be called first. 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();
    }
}
?>

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

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

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

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

Copy after login

Call var_export()

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

Called when the object copy is completed. For example, in the singleton mode implementation method mentioned in 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);
    }
}
?>

Most of the constants in PHP are unchanged, but there are 8 constants that change with their location. These 8 constants change depending on the code location. These 8 constants are called magic constants.

, 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__
, Trait name
• __METHOD__
, class method name
• __NAMESPACE__
, name of current namespace
• These magic constants are often used to obtain current environment information or record logs.

PHP Video Tutorial

The above is the detailed content of What are magic methods and magic constants in php. For more information, please follow other related articles on the PHP Chinese website!