Implementation of arrays in PHP kernel_PHP tutorial

Arrays are often used in PHP. PHP arrays are powerful and fast. Reading and writing can be completed in O(1) because the size of each element is the same. As long as you know the subscript, you can calculate it instantly. The location of its corresponding element in memory, so it can be directly taken out or written. So how are arrays implemented in the kernel?

Most functions of PHP are implemented through HashTable, including arrays.

HashTable has the advantages of a doubly linked list and has operational performance comparable to data.

• The variables defined in PHP are stored in a symbol table, and this symbol table is actually a HashTable, and each element of it is a variable of type zval*. Not only that, containers that store user-defined functions, classes, resources, etc. are implemented in the kernel in the form of HashTable.

  Let's look at how to define arrays in PHP and the kernel respectively.

  Implementation of array definition

  Define array in PHP:

  <?php
  	$array = array();
  	$array["key"] = "values";
  ?>

  
  Use macros in the kernel to achieve this:
  

  zval* array;
  array_init(array);
  add_assoc_string(array, "key", "value", 1);

  
  Expand the macro in the above code:
  

  zval* array;
  ALLOC_INIT_ZVAL(array);
  Z_TYPE_P(array) = IS_ARRAY;
  
  HashTable *h;
  ALLOC_HASHTABLE(h);
  Z_ARRVAL_P(array)=h;
  zend_hash_init(h, 50, NULL,ZVAL_PTR_DTOR, 0);
  
  zval* barZval;
  MAKE_STD_ZVAL(barZval);
  ZVAL_STRING(barZval, "value", 0);
  zend_hash_add(h, "key", 4, &barZval, sizeof(zval*), NULL);

  
  

  Convenient array macro operations

  
  

  The kernel provides us with convenient macros to manage arrays.
  

  //add_assoc_*系列函数：
  add_assoc_null(zval *aval, char *key);
  add_assoc_bool(zval *aval, char *key, zend_bool bval);
  add_assoc_long(zval *aval, char *key, long lval);
  add_assoc_double(zval *aval, char *key, double dval);
  add_assoc_string(zval *aval, char *key, char *strval, int dup);
  add_assoc_stringl(zval *aval, char *key,char *strval, uint strlen, int dup);
  add_assoc_zval(zval *aval, char *key, zval *value);
  
  //备注：其实这些函数都是宏，都是对add_assoc_*_ex函数的封装。
  
  //add_index_*系列函数：
  ZEND_API int add_index_long		(zval *arg, ulong idx, long n);
  ZEND_API int add_index_null		(zval *arg, ulong idx			);
  ZEND_API int add_index_bool		(zval *arg, ulong idx, int b	);
  ZEND_API int add_index_resource	(zval *arg, ulong idx, int r	);
  ZEND_API int add_index_double	(zval *arg, ulong idx, double d);
  ZEND_API int add_index_string	(zval *arg, ulong idx, const char *str, int duplicate);
  ZEND_API int add_index_stringl	(zval *arg, ulong idx, const char *str, uint length, int duplicate);
  ZEND_API int add_index_zval		(zval *arg, ulong index, zval *value);
  
  //add_next_index_*函数：
  ZEND_API int add_next_index_long		(zval *arg, long n	);
  ZEND_API int add_next_index_null		(zval *arg			);
  ZEND_API int add_next_index_bool		(zval *arg, int b	);
  ZEND_API int add_next_index_resource	(zval *arg, int r	);
  ZEND_API int add_next_index_double		(zval *arg, double d);
  ZEND_API int add_next_index_string		(zval *arg, const char *str, int duplicate);
  ZEND_API int add_next_index_stringl		(zval *arg, const char *str, uint length, int duplicate);
  ZEND_API int add_next_index_zval		(zval *arg, zval *value);

  Below you can compare the macros corresponding to common array operations.

  add_next_index_*()

  PHP中				内核中
  $arr[] = NULL;		add_next_index_null(arr);
  $arr[] = 42;		add_next_index_long(arr, 42);
  $arr[] = true;		add_next_index_bool(arr, 1);
  $arr[] = 3.14;		add_next_index_double(arr, 3.14);
  $arr[] = 'foo';		add_next_index_string(arr, "foo");
  $arr[] = $var;		add_next_index_zval(arr, zval);

  
  add_index_*()

  PHP中				内核中
  $arr[0] = NULL;		add_index_null(arr, 0);
  $arr[1] = 42;		add_index_long(arr, 1, 42);
  $arr[2] = true;		add_index_bool(arr, 2, 1);
  $arr[3] = 3.14;		add_index_double(arr, 3, 3.14);
  $arr[4] = 'foo';	add_index_string(arr, 4, "foo", 1);
  $arr[5] = $var;		add_index_zval(arr, 5, zval);

  
  add_assoc_*()

  PHP中					内核中
  $arr["abc"] = NULL;		add_assoc_null(arr, "abc");
  $arr["def"] = 42;		add_assoc_long(arr, "def", 42);
  $arr["ghi"] = true;		add_assoc_bool(arr, "ghi", 1);
  $arr["jkl"]  = 3.14		add_assoc_double(arr, "jkl", 3.14);
  $arr["mno"]="foo"		add_assoc_string(arr, "mno", "foo", 1");
  $arr["pqr"] = $var;		add_assoc_zval(arr, "pqr", zval);

  
  

  A complete example

  Next define a function in PHP and use an array in it. Then let's see how to implement it in the kernel.

  
  

  <?php
  function array_test(){
  	$mystr = "Forty Five";
  	$return_value = array();
  	$return_value[42] = 123;
  	$return_value[] = "test";
  	
  	$return_value[] = $mystr;
  	$return_value["double"] = 3.14;
  	
  	$mysubarray;
  	$mysubarray = array();
  	$mysubarray[] = "nowamagic";
  	
  	$return_value["subarray"] = $mysubarray;
  
  	return $return_value;
  }
  ?>

  
  Implemented in the kernel:

  PHP_FUNCTION(array_test){
  	char* mystr;
  	zval* mysubarray;
  
  	array_init(return_value);
  
  	add_index_long(return_value, 42, 123);
  
  	add_next_index_string(return_value, "test", 1);
  
  	add_next_index_stringl(return_value, "test_stringl", 10, 1);
  
  	mystr = estrdup("Forty Five");
  
  	add_next_index_string(return_value, mystr, 0);
  
  	add_assoc_double(return_value, "double", 3.14);
  
  	ALLOC_INIT_ZVAL(mysubarray);
  	array_init(mysubarray);
  	add_next_index_string(mysubarray, "hello", 1);
  	add_assoc_zval(return_value, "subarray", mysubarray);
  }

  
  You may wonder where the variable return_value in the above code is defined. Expand PHP_FUNCTION below and you will understand.

  zif_array_test(int ht, zval *return_value, zval **return_value_ptr, zval *this_ptr, int return_value_used TSRMLS_DC);

  
  That's right, in fact every function has a default return value return_value. When using RETVAL_*(), RETURN_*() as the function return value, only the return_value is modified.
  
  http://www.bkjia.com/PHPjc/777570.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/777570.htmlTechArticleArrays are often used in PHP. PHP arrays are powerful and fast. Both reading and writing can be done in O(1 ), because the size of each element is the same, as long as you know the subscript, you can instantly...