In PHP object-oriented, a series of magic methods are provided. These magic methods provide a lot of convenience for our programming. In PHP, methods starting with two underscores __ are called Magic methods, these magic methods do not need to be explicitly called but are triggered by certain conditions. This chapter will give you a brief introduction to the magic methods provided in PHP.
| ##Function
|
Description
|
__construct() | Constructor function of class |
__destruct() | Class destructor |
__call() | Called when an inaccessible method is called in an object |
__callStatic( ) | Called when calling an inaccessible method in static mode |
__get() | Called when obtaining a member variable of a class |
__set() | Called when setting a member variable of a class |
__isset() | When it is not possible Called when isset() or empty() is called to access a property |
__unset() | Called when unset() is called on an inaccessible property. |
__sleep() | When executing serialize(), this function will be called first |
__wakeup()| | When executing 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() | Call var_export( ), this static method will be called when the class is exported. |
__clone() | Called when the object copy is completed |
The "__" in the above table is two underscores, not one "_"
Let's take a look at the practical applications of these magic methods
__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 will be 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 '$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 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 are executing When serialize() and 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.
Examples are 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('server', 'username', 'password', 'db');
}
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 'this is a object';
}
}
$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 'this is a object';
}
}
$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['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 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('Clone is not allowed.' . E_USER_ERROR);
}
}
?> Recommended related articles:
Detailed explanation of magic constant examples in php
The above is the detailed content of Detailed explanation of magic method examples in php. For more information, please follow other related articles on the PHP Chinese website!
