A brief analysis of PHP principles variables (Variables inside PHP)

A brief analysis of PHP principles variables (Variables inside PHP)_PHP tutorial

WBOY

Release： 2016-07-21 14:59:46

Original

720 people have browsed it

Maybe you know, maybe you don’t know, PHP is a weakly typed, dynamic scripting language. The so-called weak type means that PHP does not strictly verify the variable type (strictly speaking, PHP is a medium-strong type language, this part will be described in a future article). When declaring a variable, it does not need to be explicitly specified. The type of data it saves:

Copy code The code is as follows:

 $var = 1 ; //int
 $var = "laruence"; //string
 $var = 1.0002; //float
 $var = array(); // array
 $var = new Exception( 'error'); //object;

Dynamic language, that is to say, the language structure of PHP can be changed during runtime. For example, we require a function definition file at runtime, resulting in language The function table changes dynamically.

The so-called scripting language means that PHP does not run independently. To run PHP we need a PHP parser:

Copy the code The code is as follows:

/usr/bin/php -f example.ph

As I mentioned in my previous article, PHP is executed through Zend engine (ZE, Zend engine) , ZE is written in C. Everyone knows that C is a strongly typed language, that is to say, all variables in C can only hold one type of data from the time they are declared until they are finally destroyed. So how does PHP implement weak types based on ZE?

In PHP, all variables are saved using a structure -zval. In Zend/zend.h we can see the definition of zval:

Copy code The code is as follows:

 typedef struct _zval_struct {
 zvalue_value value;
 zend_uint refcount;
 zend_uchar type;
 zend_uchar is_ref;
 } zval;

Among them, zvalue_value is the key part that actually saves the data. Now it’s time to reveal the answer. How does PHP implement weak types on the basis of ZE? Because zvalue_value is a union,

Copy code The code is as follows:

typedef union _zvalue_value {
 long lval ;
 double dval;
 struct {
 char *val;
 int len;
 } str;
 HashTable *ht;
 zend_object_value obj;
} z value_value; 

So how does this structure store various types in PHP?

Common variable types in PHP are:
1. Integer/floating point/long integer/bool value, etc.
2. String
3. Array/associative array
4 . Object
5. Resource

PHP stores the true type of a variable based on the type field in zval, and then chooses how to obtain the value of zvalue_value based on type, such as for integers and bool values:

Copy Code The code is as follows:

 zval.type = IS_LONG;//Plastic 
 zval.type = IS_BOOL;//Boolean

To get zval.value.lval, for bool value lval∈(0|1);
If it is double precision or float, it will get the dval of zval.value.
And if it is a string, then:

Copy the code The code is as follows:

zval.type = IS_STRIN

At this time, it will take:
zval.value.str
And this is also a structure, which stores the C-framed string and the length of the string.
For arrays and objects, type corresponds to IS_ARRAY and IS_OBJECT respectively, and correspondingly, zval.value.ht and obj respectively
What is more special is resources. In PHP, resources are a very special variable. Any variables that do not belong to PHP's built-in variable types will be treated as resources for storage, such as database handles, open file handles, etc. For resources:

Copy code The code is as follows:

type = IS_RESOURC

At this time, zval.value.lval will be fetched. At this time, lval is an integer indicator. Then PHP will query the corresponding resource in a resource list built in PHP based on this indicator (this I will introduce some of the content in a separate article in the future). For now, you only need to know that the lval at this time seems to correspond to the offset value of the resource linked list.

Copy code The code is as follows:

ZEND_FETCH_RESOURCE(con, type, zval *, default, resource_name, resource_type);

By borrowing this mechanism, PHP implements weak types, because for ZE, it always faces the same type, that is zval.