Home >Backend Development >PHP Tutorial >Detailed explanation of how to use PHP magic methods

Detailed explanation of how to use PHP magic methods

高洛峰
高洛峰Original
2017-01-06 10:13:341207browse

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

__construct(), class constructor

__destruct(), class destructor

__call(), calling an inaccessible object in the object Call

__callStatic() when calling a method, call

__get() when calling an inaccessible method in static mode, call

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

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

__unset() when calling isset() or empty() on an inaccessible property, call

__unset() when calling an inaccessible property Called when unset() is called.

__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(), when calling var_export() to export a class, This static method will be called.

__clone(), call

__construct() and __destruct()

The constructor and destructor should be familiar to them. 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 &#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 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 execute 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(&#39;server&#39;, &#39;username&#39;, &#39;password&#39;, &#39;db&#39;);
 }
 
 public function __wakeup()
 {
  $this->connect();
 }
}
?>

__toString()

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

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 will change as their location in the code changes. These 8 A constant is called a magic constant.

__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__, function Name

__CLASS__, class name

__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.

The above is the entire content of this article, I hope it will be helpful to everyone's study.

For more detailed explanations on how to use PHP Magic methods, please pay attention to the PHP Chinese website!

######
Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn