Detailed explanation of function type declarations in various versions of PHP

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

PHP7 begins to support scalar type declaration, and the flavor of strongly typed language is relatively strong. 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)

The function officially supports 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，运行出错
}

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

When parameter and return value types may be null When, the type is modified with a question mark (?), which can solve the problem of null values ​​(it does not conflict with the 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, 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

6. int

7. float

8. string

##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.

Related recommendations:

How to use type constraints to limit php function types

Introduction to JavaScript Function function types

Javascript perfect solution to determine function type_javascript skills

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