Home >Backend Development >PHP Tutorial >Implementation of type hints_PHP tutorial
Implementation of type hints_PHP tutorial
- WBOYOriginal
- 2016-07-13 10:05:29751browse
Implementation of type hints
PHP is a weakly typed language, and data types are not strictly checked when passing parameters to methods. However, sometimes it is necessary to determine the parameters passed into the method. For this reason, PHP provides some functions to determine the type of data. For example, is_numeric() determines whether it is a numeric value or a string that can be converted into a numeric value, such as the type operator used to determine the object: instanceof. instanceof is used to determine whether a given object is from a specified object class. The instanceof operator was introduced in PHP 5. Before this, is_a() was used, but its use is no longer recommended.In order to avoid problems caused by non-standard object types, the concept of type hints was introduced in PHP5. When defining method parameters, also define the object type of the parameters. If the type of the incoming parameter does not match the defined parameter type when calling, an error will be reported. In this way, the type of objects can be filtered, or the security of the data can be guaranteed.
The type hint function in PHP can only be used for hints whose parameters are objects, but cannot be used for type hints such as integers, strings, floating point, etc. After PHP5.1, PHP supports type hints for arrays.
To use type hints, just add the name of an existing class before the object type parameter of a method (or function). When using type hints, you can not only specify the object type, but also abstract classes and interfaces.
Type hint example for an array:
function array_print(Array $arr) {
print_r($arr);}
array_print(1);
There is a problem with the above code. It triggers the type hint we introduced this time. When this code is executed in versions after PHP5.1, the following error will be reported:
Catchable fatal error: Argument 1 passed to array_print() must be an array,
integer given, called in ...
When we change the integer variable in the function parameter into an array, the program will run normally and call the print_r function to output the array. So how is this type hint implemented? Whether it is a method in a class or a function we call, the function keyword is used as a mark of its declaration. The implementation of type hints is related to the declaration of the function. The type of the parameter is already determined at the time of declaration. Which, but will only be displayed when called. Here, we explain the implementation of type hints from two aspects:
Type hints when declaring parameters
Type hints when calling functions or methods
Modify the example just now:
function array_print(Array $arr = 1) {
print_r($arr);}
array_print(array(1));
Compared with the previous example, this code sets a default value for the function parameter, but this default value is an integer variable, which is different from the type hint Array given by the parameter. Therefore, when we run this When you snippet the code, you will quickly see that the program will report an error as follows:
Fatal error: Default value for parameters with array type hint
can only be an array or NULL
Why do you see the error so quickly? Because the detection process of the default value occurs in the intermediate code generation stage, unlike the error reporting at runtime, it has not yet generated the intermediate code, and there is no process of executing the intermediate code. In the Zend/zend_language_parser.y file, we find that the parameter list of the function will call the zend_do_receive_arg function at compile time. In the parameter list of this function, the fifth parameter (znode *class_type) is closely related to the type hint we want to describe in this section. The function of this parameter is to declare the type in the type hint. There are three types here:
Empty, that is, there is no type hint
Class name, user-defined or PHP-customized classes, interfaces, etc.
array, the corresponding token during compilation is T_ARRAY, which is Array string
In the zend_do_receive_arg function, a series of operations are performed on the class_type parameter, basically for the three types listed above. For the class name, the program does not determine whether the class exists, even if you use a different For existing class names, when the program reports an error, it will also be displayed that the object given by the actual parameter is not an instance of the given class.
The above is the process of declaring type hints and the process of judging the default value of parameters during the declaration process. Let's look at the implementation of type hints when calling functions or methods.
From the above declaration process, we know that PHP calls the zend_do_receive_arg function in the Zend/zend_complie.c file when compiling the code related to type hints. In this function, the opcode of the type hint judgment is assigned the value ZEND_RECV. According to the mapping calculation rules of opcode, it is concluded that ZEND_RECV_SPEC_HANDLER is called during execution. The code is as follows:
static int ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS){
...//Omit
if (param == NULL) {
char *space;
char *class_name = get_active_class_name(&space TSRMLS_CC);
zend_execute_data *ptr = EX(prev_execute_data);
if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value TSRMLS_CC)) {
…//Omit
}
…//Omit
} else {
…//Omit
zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC);
…//Omit
}
...//omitted}
As shown above: the last call in ZEND_RECV_SPEC_HANDLER is zend_verify_arg_type. The code is as follows:
static inline int zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg, ulong fetch_type TSRMLS_DC){
...//Omit
if (cur_arg_info->class_name) {
const char *class_name;
if (!arg) {
need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC);
Return zend_verify_arg_error(zf, arg_num, cur_arg_info, need_msg, class_name, "none", "" TSRMLS_CC);
}
if (Z_TYPE_P(arg) == IS_OBJECT) { // Since it is a class object parameter, the passed parameter needs to be an object type
// Next check whether this object is an instance object of the parameter prompt class. Here, it is allowed to pass subclass instance objects
need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC);
if (!ce || !instanceof_function(Z_OBJCE_P(arg), ce TSRMLS_CC)) {
return zend_verify_arg_error(zf, arg_num, cur_arg_info, need_msg, class_name, "instance of ", Z_OBJCE_P(arg)->name TSRMLS_CC);
}
} else if (Z_TYPE_P(arg) != IS_NULL || !cur_arg_info->allow_null) { // The parameter is NULL, which can also pass the check,
need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC); }
if (Z_TYPE_P(arg) != IS_ARRAY && (Z_TYPE_P(arg) != IS_NULL || !cur_arg_info->allow_null)) {
;
} *pce = zend_fetch_class(cur_arg_info->class_name, cur_arg_info->class_name_len, (fetch_type | ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD) TSRMLS_CC);
*class_name = (*pce) ? (*pce)->name: cur_arg_info->class_name;
if (*pce && (*pce)->ce_flags & ZEND_ACC_INTERFACE) {
return "implement interface ";
} else {
return "be an instance of ";
}}
static inline int zend_verify_arg_error(const zend_function *zf, zend_uint arg_num, const zend_arg_info *cur_arg_info, const char *need_msg, const char *need_kind, const char *given_msg, char *given_kind TSRMLS_DC){
zend_execute_data *ptr = EG(current_execute_data)->prev_execute_data;
char *fname = zf->common.function_name;
char *fsep;
char *fclass;
if (zf->common.scope) {
fsep = "::";
fclass = zf->common.scope->name;
} else {
fsep = "";
fclass = "";
}
if (ptr && ptr->op_array) {
zend_error(E_RECOVERABLE_ERROR, "Argument %d passed to %s%s%s() must %s%s, %s%s given, called in %s on line %d and defined", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind, ptr->op_array->filename, ptr->opline->lineno);
} else {
zend_error(E_RECOVERABLE_ERROR, "Argument %d passed to %s%s%s() must %s%s, %s%s given", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind);
}
return 0;}
在上面的代码中，我们可以找到前面的报错信息中的一些关键字Argument、 passed to、called in等。 这就是我们在调用函数或方法时类型提示显示错误信息的最终执行位置。
Statement：
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Previous article：How to implement Chinese character verification code and algorithm verification code in PHP, PHP Chinese character verification code algorithm_PHP tutorialNext article：How to implement Chinese character verification code and algorithm verification code in PHP, PHP Chinese character verification code algorithm_PHP tutorial