php __call __autoload __clone __toString __sleep

php __call __autoload __clone __toString __sleep_PHP教程

WBOY

Release： 2016-07-20 11:02:27

Original

860 people have browsed it

, __wakeup detailed explanation

1.__call
__call( $method, $arg_array ) This call is called when calling an undefined method

The object in PHP Tutorial 5 has a new special method __call(), which is used to monitor other objects in an object

Method. If you try to call a method that does not exist on the object, the __call method will be called automatically.

Example 7: __call

class foo {
function __call($name,$arguments) {
Print("did you call me? i'm $name!");
}
} $x = new foo();
$x->dostuff();
$x->fancy_stuff();
?>

This special method can be used to implement "overloading" actions so that you can check

Check your parameters and pass them by calling a private method.

2. __autoload
__autoload function, which is automatically called when trying to use a class that has not yet been defined.

Look at the example below

I have written a msyql class,

mysql tutorial.php

class mysql{
funciton __construct(){
… … }
}

Now I want to use the mysql class in the index.php page, so I do,

function __authload($class){
include_once("path".$class.".php");
}

$mysql=new mysql();

?>
include_once("path/".$class.".php");

path/ is the path where the class file is located

$class is the class name when calling

The .php behind is of course the extension,

A class file may not feel very useful. If there are many class files,

Each class must be included, which is too troublesome. Just write an __autoload() before each page, that is,

Yes,

By calling this function, the script engine has a last chance to load the required classes before php fails with an error.

3. __construct, __destruct

Constructor and destructor [__construct __destruct()] Oh, its role in the class is

Initializing and destroying variables Let’s take a look at examples

class db

{

function __construct()
{
$this->mconnid=mysql_connect ($this->dbhost,$this->dbuser,$this-

>dbpwd);//Establish connection

mysql_select_db($this->dbname, $this->mconnid); //Number of selections

Database

mysql_query("set names 'gbk'");//Set database tutorial code is gbk

}

//__destruct: destructor, disconnect

function __destruct()
{
mysql_close($this->mconnid); //There are still problems here...

}
}

At this time we don’t need to consider data connection and closing when using it, as long as $aa = new db(); it will be ok.

For more details, please see:

http://www.bkjia.com/phper/18/aa7fc14039d6f49b02c646638588be7f.htm

4.__clone

__clone magic method

We know that objects can be directly assigned, such as

$p2 = $p1; //Here is an object with two references

Then I execute:

$p1->say();

$p2->say();

Both can be executed and the effect will be the same.

We have another way:

$p3 = clone $p1; //Note that clone is the clone keyword. The difference here from the above is that $p3 is a

new objects.

At the same time, we add a method to the class:

function __clone()

{
$this->name = "I am a copy"; //Note: $this here is the object itself produced by cloning, not

is the current class
}

Then we execute:

$p3->say();

Print out

：

name: I am a copy

age:20

Here we understand that the __clone() method is executed when cloning an object. Its function is to

Newly cloned copy

Perform attribute initialization and other operations.

5.__tostring

__tostring method is automatically called when converting an object into a string

If I have a class:

class person

{
private $name = “”;
private $age = 0;

function __construct($name = “”, $age = “”)
{
$this->name = $name;
$this->age = $age;
}

function say()
{
echo “name:”.$this->name.”
”.”age:”.$this->age.”
”;
}
}

Now I instantiate this class, and then print this instance:

$p1 = new person(“liuzy”,20);
echo $p1; //Direct printing will cause errors

Obviously, printing the object directly will cause an error, because the object is a reference handle and cannot be printed directly. This

, we can use the __tostring() method. We add a __tostring() method in the person class

:
function __tostring()
{
return “i am person,my name is “.$this->name.”
”;
}

Then refresh the page. What do you find?
Now we understand that __tostring() is a method executed when printing an object directly. We can use this method

Some related information about printing class. Note: It is two underscores, the method must have a return value

6. __sleep, __wakeup
__sleep is used when serializing
__wakeup is called during deserialization

When serializing in PHP, serialize() checks whether there is __sleep() in the class. If so, this function

The number will be run before any serialization. This function must return a member attribute that needs to be serialized and saved

array, and only serializes these member attributes returned by this function. This function has two functions: First. In order

Before serializing, close any database connections the object may have, etc. Second. Specify the objects that need to be sequenced

member attributes, if an attribute is relatively large and does not need to be stored, you do not need to write it into __sleep

In the returned array, this property will not be serialized

On the contrary, after unserialize() creates an object from the byte stream, it immediately checks whether it has

The existence of __wakeup function. If present, __wakeup is called immediately. Use the __wakeup object

is to re-establish any database connections that may have been lost during serialization and handle other re-initialization tasks.

class user
{
       public $name;
       public $id;

function __construct()
          {
                $this->id = uniqid();
different ids
}

function __sleep()
                                                                                                             return(array("name"));             //do not serialize this->id no

Serialized id
}

function __wakeup()
          {
                 $this->id = uniqid(); }
}

$u = new user;
$u->name = "haha";

$s = serialize($u);
The id attribute is rowized and the value of id is discarded

$u2 = unserialize($s); //unserialize it The deserialized id is

Reassign

//$u and $u2 have different ids $u and $u2 have different ids
var_dump($u); var_dump($u2);
?>

---------- php debug ----------
object(user)#1 (2) {
["name"]=>
string(4) "haha"

["id"]=>

string(13) "47fa045529f69"
}
object(user)#2 (2) {
["name"]=>
string(4) "haha"
["id"]=>
string(13) "47fa04552a49a"
}