Detailed explanation of type declaration of functions in various versions of PHP

This article gives you a summary of how to use type declarations of functions in various versions of PHP. It is very simple and practical. Friends in need can refer to it

PHP7 starts to support scalar type declarations and strongly typed languages The flavor is stronger. I encountered two pitfalls while using this feature: once when declaring boolean, and most recently when declaring double. In order to avoid making similar mistakes in the future, I read the official documentation once. 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 , declared using the syntax 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)

Functions officially support scalar types (int , bool, float, etc.) and return value type (the declared type is the same as the parameter) declaration. Starting from this version, writing PHP feels like writing Java.

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，运行出错
}

The parameters and return value can be null and void return type declaration (PHP 7.1)

When the parameter and return value types have When it may be null, modify it with a question mark (?) before the type, which can solve the problem of null value (it does not conflict with the default parameter); the type declaration adds iterable, and also supports void type return value. 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, any type cannot be followed by return in the function body, or no return statement appears.

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

After reviewing the above history, we can see that as of PHP 7.1, function type declaration has been very complete (although it is not used much in practice).

Let’s talk about the pitfalls encountered in practice. The available types for parameter and return value type declaration are:

1. Class/Interface

2. self, which can only be used in its own methods

3. array

4. bool

5. ##callable

##int
float
string

8. ##iterable

9. 
   

   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 doesn't work when it comes to 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.

Articles you may be interested in:

Explanation on how to use PHP to count the number of occurrences of a number in a sorted array

PHP calls ffmpeg to take video screenshots and splice the script

Detailed explanation of the scenario and verification rules in Yii2

The above is the detailed content of Detailed explanation of type declaration of functions in various versions of PHP. For more information, please follow other related articles on the PHP Chinese website!