PHP function type declaration summary

PHP7 begins to support scalar type declaration, and the flavor of strongly typed language is relatively strong. I encountered two pitfalls in the process of using this feature: once when declaring boolean type parameters, and most recently when declaring double type parameters, both of which resulted in runtime errors. In order to avoid making similar mistakes in the future, I have read the official documents in the past few days. This article is a summary of the use of type declarations in PHP functions after reading it.

Grammatically, PHP function definition has gone through several periods:

Ancient times (PHP 4)

Defining a function is very simple , use the syntax declaration of function name(args) {body}. Parameter and return value types cannot be specified, and there are unlimited possible parameter and return value types. This is by far the most common way to declare a function.

Array and reference type parameter value declaration (PHP 5)

Array, class, interface, and callable can be used in the function declaration. Starting from 5.6, constants (including class constants) are supported as default parameters, as well as parameter arrays (prefixed with an ellipsis...). For example:

function sum(...$numbers) {
    $sum = 0;
    foreach ($numbers as $number) {
        $sum += $number;
    }
    return $sum;
}

Note: If the value of the parameter may be null, null must be the default value of the parameter, otherwise an error will occur when calling. For example:

function foo(array $arr = null) {
    ...
}

Scalar type and return value declaration (PHP 7)

The function officially supports scalar types (int, bool, float, string) and return value types ( The declarable type is the same as the parameter) declaration. Starting from this version, except for syntax differences, function declarations can be formally made like strongly typed languages.

Unfortunately, if the function return value may be null, the return value type cannot be specified. For example:

function getModel() : Foo {
    if ($this->_model === null) {
         $this->_model = xxxx;  // get from db or otherelse
    }
    return $this->_model;     // 如果$this->_model仍是null，运行出错
}

Parameters and return values ​​​​can be null and void return type declaration (PHP 7.1)

When the parameter and return value types may be null, the type is preceded by a question mark (?) Modification can solve the problem of null values ​​(does not conflict with default parameters); the type declaration adds iterable, and also supports void type return values. For example:

function getModel(?int $id) : ?Foo {
    if ($id !== null) {
        $this->_model = xxxx;
    } else {
        $this->_model = yyyy;
    }
    return $this->_model;
}
// 调用
$foo->getModel(null);
$foo->getModel(100);
// 函数声明了参数并且没有提供默认参数，调用时不传入参数会引发错误
// 将函数声明改成 getModel(?int $id = 100) {}，可以不传参数
$foo->getModel();

When the function return value is void, the function body cannot return anything (the writing of return void; is also wrong!), or the return statement can be omitted.

function test(array $arr) : void {
    if (!count($arr) {
        return;
    }
    // 不要return;
    array_walk($arr, function ($elem) {xxxx});
}

Looking back at the above historical changes, we can see that function type declaration has been very complete in PHP 7.1 (although it is not used much in practice). Note that the article talks about parameter and return value type declarations. PHP does not guarantee that the parameter types remain unchanged during operation, that is, the following code is legal:

function foo(array $arr) : array {
    // change $arr from array to int
    $arr = 3;
    return [];
}

From this point of view, PHP is still a weakly typed language , static compilation cannot be done.

Let’s talk about the pitfalls encountered in practice. According to the official documentation, the types available for function parameter and return value type declarations are:

● Class/Interface

● self, which can only be used in its own methods

● array

● bool

● callable

● int

● float

● string

● iterable

● void (only used in return value)

Note that there are no boolean and double types in the list! Unless you define these two types, it is wrong to use them in parameters and return values!

This is also where PHP is a bit painful. The two keywords double and float in normal use are almost the same. For example, doubleval is an alias of floatval, is_double is an alias of is_float, and (double) and (float) have the same effect when converting. But it is different when used in type declarations. The same situation occurs with bool and boolean.

Summary

The stable version of PHP 7.2 has been released. It is recommended to use PHP 7.1 and subsequent versions in new projects. In order to write clear and maintainable code, declarative types are recommended. It is recommended to use null values ​​only for reference types or strings, and try not to use null for scalar type parameters such as int/float. Try not to use func_get_argc and other functions unless necessary.

The above is the detailed content of PHP function type declaration summary. For more information, please follow other related articles on the PHP Chinese website!