Use Union types to fill in the problem of missing acquisition types in PHP8

As PHP continues to develop, language features are constantly enhanced and improved. In the PHP8 version, a new feature was introduced: Union types. Union types add type restrictions to variables, parameters, return values, etc., which can fill in the problem of missing types in the code. This article will introduce the core ideas and usage of Union types.

What are Union types?

In PHP, we often need to impose type restrictions on variables to ensure the correctness and reliability of the program. Union types provide us with a new way to achieve this requirement.

Let’s look at an example first. Suppose we have a function that needs to accept two parameters, one of type int and one of type string:

function concatenate($a, $b) {
  return $a . $b;
}

Now, we call this function and pass in two parameters:

concatenate(1, '2');

The result What is it? The answer is: '12'. This code works fine, but we have a hard time confirming its correctness. Because we have no restrictions on function parameter types, that is to say, $a and $b can be of any type.

We can use type hints to increase type restrictions:

function concatenate(int $a, string $b) {
  return $a . $b;
}

In this way, if we pass in non-int type parameters, errors will be found during the compilation phase. However, there is a problem with this: what if we want to pass in a parameter, which can be of type int or string? You may implement it like this:

function concatenate($a, $b) {
  if (is_int($a) && is_string($b)) {
    return $a . $b;
  } elseif (is_string($a) && is_int($b)) {
    return $b . $a;
  } else {
    throw new Exception('Invalid arguments');
  }
}

This way of writing is very cumbersome and the code readability is also very poor.

In PHP8, we can use Union types to solve this problem:

function concatenate(int|string $a, int|string $b) {
  return $a . $b;
}

This function can accept two parameters, they can be int type or string type, that is, as long as If the parameter type is either int or string, you can call this function normally.

Usage

Union types can be used in parameters, return values, class attributes, etc. Below we introduce each usage separately.

Parameters

Union types can be used in function parameters. In this way, we can limit multiple types of parameters. Just use the | symbol to connect different types. For example:

function foo(int|float $x, string $y) {
  // ...
}

The above function accepts two parameters, $x can be of int or float type, and $y must be of string type.

Return value

Similarly, we can also use Union types at the return value of the function:

function bar(int $x): int|string {
  if ($x > 0) {
    return $x * 2;
  } else {
    return 'error';
  }
}

This function accepts an int type parameter $x, and the return value can be Is of type int or string. If $x is greater than 0, return 2 times $x; otherwise return the string 'error'.

Class attributes

Union types can also be used when defining class attributes:

class MyClass {
  public int|string $x;
}

In this example, MyClass has an attribute $x, and its type can be int or string type.

Notes

Although Union types provide us with a new way to perform type restrictions, we still need to pay attention to some things.

First of all, use Union types as little as possible. Excessive type restrictions will reduce code readability and increase the difficulty of maintenance. Choosing appropriate types to limit parameters and return values ​​can make your code more concise, clear, and easier to maintain.

Secondly, when using Union types, type casts should be avoided as much as possible. Because this will cause type safety issues.

Finally, Union types are not a perfect solution. For type judgment in some cases, we still need to use if statements to make judgments.

Conclusion

Union types provide us with a completely new way to perform type restrictions. By using Union types in parameters, return values, and class attributes, we can more tightly control the type safety of our code, thereby improving the reliability and maintainability of our programs. However, when using Union types, we still need to pay attention to issues such as code readability and type safety. Only by choosing appropriate types for restrictions can we ensure the stability and robustness of the code.

The above is the detailed content of Use Union types to fill in the problem of missing acquisition types in PHP8. For more information, please follow other related articles on the PHP Chinese website!