PHP kernel exploration: variable storage and type

Answer the question in the previous section first.

01 <? Php
02 $ foo = 10;
03 $ bar = 20;
04
05 functionchange () {
06 global $ foo;
07 // echo ‘$ foo inside function =‘. $ Foo. ’<br />‘;
08 // If $ bar is not defined as a global variable, the function body cannot access $ bar
09 $ bar = 0;
10 $ foo ++;
11}
12
13 change ();
14 echo $ foo, ‘‘, $ bar;
15?>

Program Output 11 20. The reason is that the $bar variable cannot be accessed inside the method, so its value is still 20. After using global, you can get the value of $foo, and the value of $foo after increment is 11.

The role of global is to define globals, but this global variable is not applied to the entire site, but to the current page, including all files of include or require.

The preface mentions three basic characteristics of a variable, one of which is the type of the variable, and the variable has a specific type, such as: String, Array, object, and so on. The type system of a programming language can be divided into two types: strong and weak.

A strongly typed language is when a variable is declared to be a variable of a type, it is not possible to assign a value other than the type of the variable to it while the program is running (this is not entirely true, this may involve the conversion of the type, which is described later in the section), and C/c++/java and other languages fall into this category.

Scripting languages such as PHP and Ruby,javascript are weak-type languages: A variable can represent any data type.

PHP has become a simple and powerful language, and a large part of it is because it has weak-type variables. But sometimes this is also a double-edged sword, improper use will also bring some problems. Just like the instrument, the more powerful it is, the greater the likelihood of error.

Within the official PHP implementation, all variables are saved using the same data structure (Zval), which represents a variety of data types in PHP. It contains not only the value of the variable, but also the type of the variable. This is the core of PHP's weak type.

The ZVAL structure specifically how to achieve the weak type, we will come together to uncover the veil.

Variable storage structure

When you declare or use a variable, PHP does not need to explicitly indicate its data type.

PHP is a weakly typed language, which does not mean that PHP has no type, in PHP, there are 8 types of variables, can be divided into three categories

• * Scalar type:boolean,integer,float (double),string
• * Composite type: array,object
• * Special Type: resource,NULL

The official PHP is implemented in C, and C is a strong type of language, how does this implement the weak type in PHP?

The value of the variable is stored in the ZVAL structure as shown below. The ZVAL structure is defined in the Zend/zend.h file, and its structure is as follows:

1	typedefstruct_zval_struct zval;
2	...
3	struct_zval_struct {
4	    /* Variable information */
5	    zvalue_value value;     /* value */
6	    zend_uint refcount__gc;
7	    zend_uchar type;    /* active type */
8	    zend_uchar is_ref__gc;
9	};

PHP uses this structure to store all the data for a variable. Unlike other compiled static languages, PHP stores variable types of PHP user space in the same structure when storing variables. This allows us to obtain the type of the variable through this information.

There are four fields in the Zval structure, which have the following meanings:

Property name	meaning	Default Value
refcount__gc	Represents a reference count	1
is_ref__gc	Indicates whether it is a reference	0
Value	Value of the stored variable
Type	Variable-specific type

After PHP5.3, a new garbage collection mechanism was introduced, with reference counts and referenced field names changed to REFCOUNT__GC and IS_REF__GC. Before this is refcount and is__ref.

The value of the variable is stored in another struct zvalue_value. The value store is described below.

PHP user space refers to the level of the PHP language, and most of the book is about the implementation of PHP. These implementations can be understood as kernel space. Since PHP is implemented in C, the scope of this space is limited to the C language. PHP User space is limited by the PHP syntax and functionality provided by the scope. For example, some PHP extensions provide PHP functions or classes, which are the methods or classes that are exported to the PHP user space.

Variable type

The Type field of the Zval struct is the most critical field that implements the weak type, and the value of type can be: Is_null, Is_bool, Is_long, is_double, is_string, Is_array, Is_object, and Is_ One of the RESOURCE. It's literally good to understand that they are just types of unique indicators that store different values in the Value field depending on the type. In addition, the types that are defined with them are is_constant and Is_constant_array.

This is similar to what we did when we designed the database, in order to avoid repeating the design of similar tables, using an indicator field to record different types of data.

The value of the variable is stored

The values of the variables mentioned above are stored in the Zvalue_value union, and the structure is defined as follows:

01	typedefunion_zvalue_value {
02	    longlval;                  /* long value */
03	    doubledval;                /* double value */
04	    struct{
05	        char*val;
06	        intlen;
07	    } str;
08	    HashTable *ht;              /* hash table value */
09	    zend_object_value obj;
10	} zvalue_value;

The use of a consortium instead of a struct is a consideration for space utilization, because a variable can only belong to one type at a time. If you use structs, you will waste space unnecessarily, and all of the logic in PHP is going around variables, so memory waste will be huge. The cost of this approach is small but the benefits are very large.

Various types of data use different methods to store variable values, and their corresponding assignments are as follows:

1. General type

Variable Type	Macro	?
Boolean	Zval_bool	The value of a Boolean/integer variable is stored in the (zval). Value.lval, its type is also stored in the corresponding is_*. Z_type_p (z) =is_bool/long;
Integer	Zval_long
Float	Zval_double
Null	Zval_null	The variable value of the NULL value does not need to be stored, just the (zval). Type is labeled Is_null.
Resource	Zval_resource	The storage of resource types is the same as other general variables, but its initialization and access implementations are different. Z_type_p (z) = Is_resource;

2. String sting

The type of the string is the same as other data types, but there is one more string-length field when storing the string.

1	struct{
2	    char*val;
3	    intlen;
4	} str;

The string in C is an array of characters ending in a., where the length of the string is stored, which is the same as the redundant fields we added when designing the database. Because the time complexity to get the length of a string in real time is O (n), and the operation of the string is very frequent in PHP, it avoids the repetition of the length of the string, which can save a lot of time and is a space-time approach. So the strlen () function in PHP can get the length of a string in constant time. There are many strings in the computer language, so the length of the string is stored in most high-level languages.

3. Array of arrays

Arrays are the most commonly used and most powerful variable types in PHP, which can store other types of data and provide a variety of built-in manipulation functions. The storage of an array is more complex than other variables, and the value of the array is stored in the Zvalue_value.ht field, which is a hashtable type of data. An array of PHP uses a hash table to store the associated data. A hash table is an efficient storage structure for key-value pairs. PHP's hash table implementation uses two data structures hashtable and buckets. All of PHP's work is implemented by a hash table, and the basic concept of hash table is introduced in the next section Hashtable and the PHP hash table is implemented.

4. Object

In object-oriented languages, we can define our own data types, including the properties of classes, methods, and so on. The object is a concrete implementation of the class. The object has its own state and the actions it can accomplish.

The object of PHP is a compound type of data, which is stored using a zend_object_value structure. It is defined as follows:

1 typedefstruct_zend_object_value { 2 zend_object_handle handle; // unsigned int type，EG(objects_store).object_buckets的索引 3 zend_object_handlers *handlers; 4 } zend_object_value;

PHP objects are created only at run time, and the previous section describes the eg macro, which is a global structure used to hold data at run time. This includes the object pool used to hold all the objects created, EG (Objects_store), and the Zend_object_handle field of the object value content is the index of the current object in the object pool. The Handlers field is a handler that saves the object when it is manipulated. The structure of the struct and object-related classes is _zend_class_entry, which is described later.

PHP's weak-variable containers are implemented in an inclusive form, with their corresponding tags and storage space for each type of variable. Using strongly typed languages is often more efficient than weak types, because much of the information can be determined before it is run, which can also help eliminate program errors. The problem is that writing code is relatively constrained.

The main purpose of PHP is as a web development language, where bottlenecks in common Web applications are typically at the level of business and data access. But language can also be a key factor in large-scale applications. Facebook has therefore used its own PHP implementation. Compile PHP into C + + code to improve performance. But Facebook's hiphop is not a complete PHP implementation, because it compiles PHP directly into C + +, some PHP dynamic features such as the eval structure can not be implemented. Of course, there is a way to achieve, hiphop not realize should also do a trade-off.

Extended Reading

The list of topics for this article is as follows:

2. PHP Kernel Explorer: Starting with the SAPI interface
4. PHP kernel exploration: Start and end of a single request
6. PHP kernel exploration: One-time request life cycle
8. PHP Kernel Exploration: single-process SAPI life cycle
10. PHP kernel Exploration: SAPI lifecycle of multiple processes/threads
12. PHP Kernel Explorer: Zend Engine
14. PHP Kernel Explorer: Explore SAPI again
16. PHP kernel Discovery: Apache module Introduction
18. PHP Kernel Explorer: PHP support via MOD_PHP5
20. PHP kernel exploration: Apache Run with hook function
22. PHP Kernel Explorer: embedded PHP
24. PHP Kernel Explorer: PHP fastcgi
26. PHP kernel exploration: How to execute PHP scripts
28. PHP Kernel Explorer: PHP script execution details
30. PHP kernel exploration: opcode opcode
32. PHP kernel Explorer: PHP opcode
34. PHP kernel exploration: Interpreter execution process
36. PHP Kernel Exploration: Variables overview
38. PHP kernel exploration: variable storage and type
40. PHP Kernel Explorer: Hash table in PHP
42. PHP Kernel Exploration: Understanding the hash table in Zend
44. PHP kernel exploration: PHP hash Algorithm design
46. PHP kernel Exploration: translating an article hashtables
48. PHP Kernel exploration: What is a hash collision attack?
50. PHP Kernel exploration: implementation of constants
52. PHP kernel exploration: Storage of variables
54. PHP kernel exploration: Types of variables
56. PHP Kernel Explorer: Variable value operation
58. PHP Kernel exploration: Creation of variables
60. PHP kernel exploration: pre-defined variables
62. PHP Kernel Explorer: variable retrieval
64. PHP kernel Exploration: Variable type conversion
66. PHP Kernel exploration: implementation of weakly typed variables
68. PHP Kernel exploration: implementation of static variables
70. PHP Kernel Explorer: Variable type hints
72. PHP kernel exploration: The life cycle of a variable
74. PHP Kernel Exploration: variable assignment and destruction
76. PHP Kernel exploration: variable scope
78. PHP kernel Explorer: Weird variable names
80. PHP Kernel Explorer: variable value and type storage
82. PHP Kernel Explorer: global variables
84. PHP kernel Exploration: Conversion of variable types
86. PHP kernel Exploration: The memory management begins
88. PHP Kernel Explorer: Zend Memory manager
90. PHP Kernel Explorer: PHP's memory management
92. PHP Kernel Exploration: Application and destruction of memory
94. PHP Kernel Exploration: reference count vs. write-time replication
96. PHP kernel exploration: PHP5.3 garbage collection mechanism
98. PHP Kernel Explorer: Cache in memory management
100. PHP Kernel Exploration: write-time copy cow mechanism
102. PHP kernel Exploration: arrays and Linked lists
104. PHP kernel exploration: Using the Hash Table API
106. PHP kernel exploration: array manipulation
108. PHP kernel Exploration: Array source code Analysis
110. PHP Kernel Exploration: Classification of functions
112. PHP kernel Exploration: internal structure of functions
114. PHP Kernel exploration: function structure transformation
116. PHP Kernel Exploration: The process of defining a function
118. PHP kernel Exploration: Parameters for functions
120. PHP kernel exploration: zend_parse_parameters function
122. PHP Kernel exploration: function return value
124. PHP kernel exploration: formal parameter return value
126. PHP Kernel exploration: function invocation and execution
128. PHP kernel exploration: Referencing and function execution
130. PHP kernel exploration: anonymous functions and closures
132. PHP Kernel Exploration: object-oriented opening
134. PHP kernel Exploration: The structure and implementation of classes
136. PHP kernel exploration: member Variables for classes
138. PHP Kernel Exploration: Member Methods for classes
140. PHP Kernel Exploration: class prototype Zend_class_entry
142. PHP kernel exploration: Definition of class
144. PHP Kernel Explorer: Access control
146. PHP kernel exploration: inheritance, polymorphism and abstract classes
148. PHP Kernel Exploration: magic function and delay binding
150. PHP kernel Exploration: Preserving classes and special classes
152. PHP Kernel Explorer: objects
154. PHP kernel Exploration: Creating object instances
156. PHP Kernel Explorer: Object properties Read and write
158. PHP Kernel Exploration: namespaces
160. PHP kernel exploration: Defining interfaces
162. PHP kernel Exploration: Inheritance and Implementation interface
164. PHP Kernel Exploration: resource resource type
166. PHP Kernel Explorer: Zend virtual machine
168. PHP Kernel Exploration: Lexical parsing of virtual machines
170. PHP Kernel Explorer: virtual machine Syntax analysis
172. PHP kernel exploration: Execution of intermediate code opcode
174. PHP Kernel Exploration: Code encryption and decryption
176. PHP kernel exploration: zend_execute specific execution process
178. PHP kernel exploration: Reference and counting rules for variables
180. PHP kernel exploration: New garbage collection Mechanism description

PHP kernel exploration: variable storage and type