PHP 5.3 new magic method __invoke overview, 5.3__invoke_PHP tutorial

Overview of the new magic method __invoke in PHP 5.3, 5.3__invoke

PHP has added a new magic method called __invoke since version 5.3. Using this method, you can directly call the object after creating the instance. As shown in the following example:

class testClass
{
public function __invoke
{
print "hello world";
}
}
$n = new testClass;
$n();

The execution result is:

hello world。

The official php example is as follows:

class CallableClass
{
public function __invoke($x)
{
var_dump($x);
}
}
$obj = new CallableClass;
$obj(5);
var_dump(is_callable($obj));

Attachment: Detailed explanation of other magic methods in PHP:

Classes in php can use magic methods. It stipulates that methods starting with two underscores (__) are reserved as magic methods, so it is recommended that function names do not start with __ unless it is to overload an existing magic method.

The function names __construct, __destruct, __call, __callStatic, __get, __set, __isset, __unset, __sleep, __wakeup, __toString, __invoke, __set_state and__clone are magical in PHP classes. You cannot have functions with these names in any of your classes unless you want the magic functionality associated with them.

The following two methods are designed for properties that are not declared in the class and their parent class.
__get($property) This method will be triggered when an undefined property is called, and the parameter passed is the name of the property being accessed.
__set($property,$value) When assigning a value to an undefined property, this method will be triggered, and the parameters passed are the property name and value to be set.
The non-declaration here includes attributes whose access control is protected and private (that is, attributes that have no permission to access) when called using objects.
The same as the __get method and __set method, the undeclared here includes attributes whose access control is protected and private (that is, attributes that have no permission to access) when called using an object.

The undefined methods here include methods that do not have permission to access; if the method does not exist, go to the parent class to find the method. If it does not exist in the parent class, call the __call() method of this class. , if the __call() method does not exist in this class, go to the __call() method in the parent class .

__autoload function , which is automatically called when trying to use a class that has not been defined yet. By calling this function, the script engine has a last chance to load the required classes before PHP fails with an error.

Note: Exceptions thrown in the __autoload function cannot be caught by the catch statement block and cause fatal errors, so they should be caught in the function itself.

__construct constructor method, this method is called when an object is created. The advantage of using this method compared to php4 is that the constructor method can have a unique name, regardless of the name of the class in which it is located. What. So when you change the name of the class, you don't need to change the name of the constructor.

__destruct destructor method, PHP will call this method before the object is destroyed (that is, before it is cleared from memory). By default, PHP only releases the memory occupied by object properties and destroys object-related resources. The destructor allows you to execute arbitrary code to clear memory after using an object. When PHP decides that your script is no longer associated with the object, the destructor will be called.

Within a function's namespace, this happens when the function returns. For global variables, this happens at the end of the script. If you want to explicitly destroy an object, you can assign any other value to the variable pointing to the object. Typically assign the variable to null or call unset.

Object assignment in php5 uses reference assignment. If you want to copy an object, you need to use the clone method. When calling this method, the object will automatically call the __clone magic method. If you need to perform some initialization operations when copying the object, This can be achieved in the __clone method.

__tostring method is automatically called when converting an object into a string, such as when using echo to print the object.

Before php5.2.0, the __tostring method could only take effect when used in combination with echo() or print(). After php5.2.0, it can take effect in any string environment (for example, through printf(), using the %s modifier), but it cannot be used in non-string environments (such as using the %d modifier). From php5.2.0, if an object that does not define the __tostring method is converted to a string, an e_recoverable_error error will be reported.

__wakeupCalled during deserialization

serialize() checks whether there is a function with the magic name __sleep in the class. If so, the function will run before any serialization. It clears the object and should return an array containing the names of all variables in the object that should be serialized.

The purpose of using __sleep is to close any database connections the object may have, submit pending data, or perform similar cleanup tasks. Additionally, this function is useful if you have very large objects that do not need to be stored completely.

PHP Conversely, unserialize() checks for the existence of a function with the magic name __wakeup. This function can reconstruct any resources the object may have, if present. The purpose of using __wakeup is to reestablish any database connections that may have been lost during serialization and to handle other reinitialization tasks.
When trying to call an object by calling a function, the __invoke method is automatically called.

It works similar to the __call() magic method, __callstatic() is to handle static method calls.

PHP does tighten the definition of the __callstatic() method; it must be public and must be declared static. Likewise, the __call() magic method must be defined as public, as must all other magic methods.

This detour is for safety, which is the concept of encapsulation in object-oriented. If Public is set directly, every object can freely set the value of this attribute, and there is no task logic judgment. This detour can increase security. Sex

The core of PHP's object processing part has been completely redeveloped, providing more functions and improving performance. In previous versions of PHP, objects were handled the same way as basic types (numbers, strings). The disadvantage of this method is that when assigning the object to a variable or passing the object through parameters, the object will be completely copied. In the new version, the above operation will pass a reference (reference can be understood as an identifier of the object) instead of a value.
Many PHP programmers may not even be aware of the old way of handling objects. In fact, most PHP applications will run just fine. Or only minimal changes are needed.
Private and protected members
PHP5 introduces the concept of private and protected member variables. We can use it to define the visibility of class members.
Example
Protected members can be accessed by subclasses, while private members can only be accessed by the class itself.

Code:--------------------------------------------- -------------------------------------

class MyClass {
private $Hello = "Hello, World!\n";
protected $Bar = "Hello, Foo!\n";
protected $Foo = "Hello, Bar!\n ";

function printHello() {
print "MyClass::printHello() " . $this->Hello;
print "MyClass::printHello() " . $this-> ;Bar;
print "MyClass::printHello() " . $this->Foo;
}
}

class MyClass2 extends MyClass {
protected $Foo;

function printHello() {
MyClass::printHello(); /* Should print */
print "MyClass2::printHello() " . $this->Hello; /* Shouldn' t print out anything */
print "MyClass2::printHello() " . $this->Bar; /* Shouldn't print (not declared)*/
print "MyClass2::printHello() " . $this->Foo; /* Should print */
}
}

$obj = new MyClass();
print $obj->Hello; /* Shouldn 't print out anything */
print $obj->Bar; /* Shouldn't print out anything */
print $obj->Foo; /* Should...the rest of the text >>