PHP code optimization member variable acquisition speed comparison_PHP tutorial

There are 4 code examples below. What do you think is the order of speed in creating objects and obtaining member variables?

1: Set the member variable to public, assign a value to the member variable through the assignment operation, and directly obtain the variable

Copy code The code is as follows:

class Foo {
public $id;
}
$data = new Foo;
$data->id = 10;
echo $data->id;
?>

2: Set the member variable to public, set the value of the member variable through the constructor, and directly obtain the variable

Copy code The code is as follows:

class Foo2 {
public $id;
public function __construct( $id) {
$this->id = $id;
}
}

$data = new Foo2(10);
echo $data->id;
?>

3: Set the member variable to protected through the constructor Set the value of the member variable and obtain the variable through the magic method

Copy the code The code is as follows:

class Foo3 {
protected $id;
public function __construct($id) {
$this->id = $id;
}

public function getId() {
return $this->id;
}
}
$data = new Foo3(10);
echo $data->getId ();
?>

4: Set the member variable to protected, set the value of the member variable through the constructor, and obtain the variable through the member method
class Foo4 {
protected $id;
public function __construct($id) {
$this->id = $id;
}

public function __get($key) {
return $this->id;
}
}
$data = new Foo4(10);
echo $data-> ;id;
?>
Sort by execution speed: 1243
Let’s look at its opcode first:
1:

Copy code The code is as follows:

1 ZEND_FETCH_CLASS 4 :4 'Foo'
2 NEW $5:4
3 DO_FCALL_BY_NAME 0 !0, $5
5 ZEND_ASSIGN_OBJ !0, 'id'
6 ZEND_OP_DATA 10
7 FETCH_OBJ_R $9 !0, 'id'
8 ECHO $9

2:

Copy code The code is as follows:

1 ZEND_FETCH_CLASS 4 :10 'Foo2'
2 NEW $11 :10
3 SEND_VAL 1 0
4 DO_FCALL_BY_NAME 1
5 ASSIGN !1, $11
6 FETCH_OBJ_R $14 !1, 'id'
7 ECHO $14

3:

Copy code The code is as follows:

1 ZEND_FETCH_CLASS 4 :15 'Foo3'
2 NEW $16 :15
3 SEND_VAL 10
4 DO_FCALL_BY_NAME 1
5 ASSIGN !2, $16
6 ZEND_INIT_METHOD_CALL !2, 'getId'
7 DO_FCALL_BY_NAME 0 $20
8 ECHO $20

4:

Copy code The code is as follows:

1 ZEND_FETCH_CLASS 4 :21 'Foo4'
2 NEW $22:21
3 END_VAL 10
4 DO_FCALL_BY_NAME 1 ASSIGN !3, $22
6 FETCH_OBJ_R $25 ! 3, 'id'
7 ECHO $25

According to the above opcode and the corresponding opcode implementation in the zend_vm_execute.h file, what can we find?

1. The process of object creation by the PHP kernel is divided into three steps:

ZEND_FETCH_CLASS obtains the variable of the storage class according to the class name, which is implemented as a hashtalbe EG(class_table) search operation
NEW initializes the object and points EX(call)->fbc to the constructor pointer.
Call the constructor. The call is the same as other function calls. They all call zend_do_fcall_common_helper_SPEC

2. The call of the magic method is triggered by conditions, not directly, such as the members in our example To obtain the variable id

(zend_std_read_property), the steps are:
Get the properties of the object. If it exists, go to the second step; if there is no relevant attribute, go to the third step
From the properties of the object Find whether there is an attribute corresponding to the name. If it exists, return the result. If it does not exist, go to the third step
If there is a __get magic method, call this method to get the variable. If it does not exist, report an error
Return to Sorting questions:

1. What is the difference between the first and the second?

The second one has fewer opcodes than the first one, but is slower than the first one because the constructor has more parameters and one more opcode for parameter processing. Parameter processing is a relatively time-consuming operation. When we are doing code optimization, we can remove some unnecessary parameters as much as possible. When a function has multiple parameters, we can consider encapsulating them in an array and passing them in.

2. Why is the third one the slowest?

Because getting parameters is essentially a call to an object member method, the cost of calling a method is higher than getting a variable

3. Why is the fourth one faster than the third one?

Because the fourth operation actually obtains the variable, but it implements the magic method call internally. Compared with the user-defined method, the efficiency of calling the internal function will be higher. Therefore, we should not reinvent the wheel when we have some methods implemented by the PHP kernel that can be called.
4. Why is the fourth one slower than the second one?
Because in the process of PHP object obtaining variables, when the member variable is no longer in the definition of the class, PHP's unique magic method __get will be called, adding one more magic method call.

To summarize:

1. Use PHP built-in functions
2. Not everything must be object-oriented (OOP), object-oriented is often very expensive, and every method and object call will Consumes a lot of memory.
3. Use magic methods as little as possible -- unless necessary, do not use frameworks, because frameworks have a large number of magic methods.
4. In performance-first application scenarios, using member variables is a better method when you need to use OOP.
5. If you can use PHP syntax structures, don’t use functions. If you can use built-in functions, don’t write them yourself. If you can use functions, don’t use objects.

http://www.bkjia.com/PHPjc/736832.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/736832.htmlTechArticleThere are 4 code examples below. What do you think is the order of speed in creating objects and obtaining member variables? 1: Set the member variables to public and assign values ​​to the member variables...