第八节 匿名函数及闭包

[php]
<?php
$array = array(1, 2, 3, 4);
array_walk($array, create_function('$value', 'echo $value;'));

[php]
<?php
function a() {
	echo 'function a';
}
$a = 'a';
$a();

[php]
<?php
function do_something($callback) {
	// doing
	# ...
	// done
	$callback();
}

[php]
<?php
$func = create_function('', 'echo "Function created dynamic";');
echo $func; // lambda_1
$func();    // Function created dynamic
$my_func = 'lambda_1';
$my_func(); // 不存在这个函数
lambda_1(); // 不存在这个函数

[php]
<?php
$func = create_function('', 'echo "Hello";');
$my_func_name = 'lambda_1';
debug_zval_dump($func); 		// string(9) "lambda_1" refcount(2)
debug_zval_dump($my_func_name); // string(8) "lambda_1" refcount(2)

[c]
#define LAMBDA_TEMP_FUNCNAME    "__lambda_func"
ZEND_FUNCTION(create_function)
{
	// ... 省去无关代码
	function_name = (char *) emalloc(sizeof("0lambda_")+MAX_LENGTH_OF_LONG);
	function_name[0] = '\0';  // <--- 这里
	do {
		function_name_length = 1 + sprintf(function_name + 1, "lambda_%d", ++EG(lambda_count));
	} while (zend_hash_add(EG(function_table), function_name, function_name_length+1, &new_function, sizeof(zend_function), NULL)==FAILURE);
	zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
	RETURN_STRINGL(function_name, function_name_length, 0);
}

[php]
<?php
$my_func = chr(0) . "lambda_1";
$my_func(); // Hello

1. 函数的定义是通过字符串动态eval的， 这就无法进行基本的语法检查;
2. 这类函数和普通函数没有本质区别， 无法实现闭包的效果.

[php]
<?php
class Callme {
	public function __invoke($phone_num) {
		echo "Hello: $phone_num";
	}
}
$call = new Callme();
$call(13810688888); // "Hello: 13810688888

[php]
<?php
$func = function() {
	echo "Hello, anonymous function";
}
echo gettype($func); 	// object
echo get_class($func); 	// Closure

[javascript]
var a = {};
a.call = function() {alert("called");}
a.call(); // alert called

[php]
<?php
$name = 'TIPI Team';
$func = function() use($name) {
	echo "Hello, $name";
}
$func(); // Hello TIPI Team

[php]
<?php
function getCounter() {
	$i = 0;
	return function() use($i) { // 这里如果使用引用传入变量: use(&$i)
		echo ++$i;
	};
}
$counter = getCounter();
$counter(); // 1
$counter(); // 1

[php]
<?php
$i=100;
$counter = function() use($i) {
	debug_zval_dump($i);
};  
$counter();

$ php -dvld.active=1 closure.php
vars:  !0 = $i, !1 = $counter
# *  op                           fetch          ext  return  operands
------------------------------------------------------------------------
0  >   ASSIGN                                                   !0, 100
1      ZEND_DECLARE_LAMBDA_FUNCTION                             '%00%7Bclosure
2      ASSIGN                                                   !1, ~1
3      INIT_FCALL_BY_NAME                                       !1
4      DO_FCALL_BY_NAME                              0      
5    > RETURN                                                   1
function name:  {closure}
number of ops:  5
compiled vars:  !0 = $i
line     # *  op                           fetch          ext  return  operands
--------------------------------------------------------------------------------
  3     0  >   FETCH_R                      static              $0      'i'
		1      ASSIGN                                                   !0, $0
  4     2      SEND_VAR                                                 !0
		3      DO_FCALL                                      1          'debug_zval_dump'
  5     4    > RETURN                                                   null

[c]
static int ZEND_FASTCALL  ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
	zend_op *opline = EX(opline);
	zend_function *op_array;
		  
	if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), Z_LVAL(opline->op2.u.constant), (void *) &op_arra
y) == FAILURE ||
		op_array->type != ZEND_USER_FUNCTION) {
		zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
	}
	zend_create_closure(&EX_T(opline->result.u.var).tmp_var, op_array TSRMLS_CC);
	ZEND_VM_NEXT_OPCODE();
}   

[c]
ZEND_API void zend_create_closure(zval *res, zend_function *func TSRMLS_DC)
{
	zend_closure *closure;
	object_init_ex(res, zend_ce_closure);
	closure = (zend_closure *)zend_object_store_get_object(res TSRMLS_CC);
	closure->func = *func;
	if (closure->func.type == ZEND_USER_FUNCTION) { // 如果是用户定义的匿名函数
		if (closure->func.op_array.static_variables) {
			HashTable *static_variables = closure->func.op_array.static_variables;
			// 为函数申请存储静态变量的哈希表空间
			ALLOC_HASHTABLE(closure->func.op_array.static_variables); 
			zend_hash_init(closure->func.op_array.static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);
	
			// 循环当前静态变量列表， 使用zval_copy_static_var方法处理
			zend_hash_apply_with_arguments(static_variables TSRMLS_CC, (apply_func_args_t)zval_copy_static_var, 1, closure->func.op_array.static_variables);
		}
		(*closure->func.op_array.refcount)++;
	}
	closure->func.common.scope = NULL;
}

[c]
static int zval_copy_static_var(zval **p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key)
{
	HashTable *target = va_arg(args, HashTable*);
	zend_bool is_ref;
	// 只对通过use语句类型的静态变量进行取值操作， 否则匿名函数体内的静态变量也会影响到作用域之外的变量
	if (Z_TYPE_PP(p) & (IS_LEXICAL_VAR|IS_LEXICAL_REF)) {
		is_ref = Z_TYPE_PP(p) & IS_LEXICAL_REF;
		if (!EG(active_symbol_table)) {
			zend_rebuild_symbol_table(TSRMLS_C);
		}
		// 如果当前作用域内没有这个变量
		if (zend_hash_quick_find(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, (void **) &p) == FAILURE) {
			if (is_ref) {
				zval *tmp;
				// 如果是引用变量， 则创建一个临时变量一边在匿名函数定义之后对该变量进行操作
				ALLOC_INIT_ZVAL(tmp);
				Z_SET_ISREF_P(tmp);
				zend_hash_quick_add(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), (void**)&p);
			} else {
				// 如果不是引用则表示这个变量不存在
				p = &EG(uninitialized_zval_ptr);
				zend_error(E_NOTICE,"Undefined variable: %s", key->arKey);
			}
		} else {
			// 如果存在这个变量， 则根据是否是引用， 对变量进行引用或者复制
			if (is_ref) {
				SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
			} else if (Z_ISREF_PP(p)) {
				SEPARATE_ZVAL(p);
			}
		}
	}
	if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, p, sizeof(zval*), NULL) == SUCCESS) {
		Z_ADDREF_PP(p);
	}
	return ZEND_HASH_APPLY_KEEP;
}