PHP 8 联合类型（Union Types）与类型检查：代码健壮性与IDE提示的提升
大家好！今天我们来聊聊PHP 8中一个非常重要且实用的特性：联合类型（Union Types）。我们将深入探讨联合类型的概念、用法、优势以及它如何提升代码的健壮性和改善IDE的提示效果。
什么是联合类型？
在PHP 8之前，我们定义函数参数、返回值或类属性的类型时，只能指定一个类型。例如，一个函数参数要么是整数，要么是字符串，不能同时接受两者。但现实场景中，很多时候我们需要一个参数或返回值能够接受多种类型，比如一个处理用户ID的函数，可能需要接受整数型的用户ID，也可能需要接受字符串型的用户ID（比如UUID）。
联合类型正式解决了这个问题。它允许我们为一个变量或函数参数指定多个可能的类型。使用竖线 | 分隔不同的类型，表示该变量或参数可以是这些类型中的任何一个。
基本语法：
<?php
// 函数参数可以接受 int 或 string 类型
function processId(int|string $id): void {
// ...
}
// 类属性可以接受 int 或 float 类型
class MyClass {
public int|float $value;
}
// 函数返回值可以接受 array 或 null 类型
function getData(): array|null {
// ...
}
?>联合类型的优势
联合类型带来的优势是多方面的：
- 更清晰的类型声明： 联合类型使得代码的类型声明更加准确和清晰。相比于使用类型提示
mixed或者使用注释@param和@return来模拟联合类型，联合类型提供了原生支持，更易于阅读和维护。 - 更强的类型检查： PHP引擎可以对联合类型进行更严格的类型检查。如果传入的参数或返回值的类型与联合类型不匹配，PHP会抛出
TypeError异常，帮助我们在运行时发现潜在的类型错误。 - 更好的代码健壮性： 通过更强的类型检查，联合类型可以帮助我们编写更加健壮的代码，减少因类型错误导致的bug。
- 改善IDE提示： IDE能够更好地理解联合类型，从而提供更准确的代码补全、错误检测和类型推断。
联合类型的用法
下面我们通过一些具体的例子来说明联合类型的用法。
1. 函数参数的联合类型：
假设我们需要编写一个函数，用于格式化数字。该函数可以接受整数或字符串类型的数字，并返回格式化后的字符串。
<?php
function formatNumber(int|string $number, int $decimals = 2): string {
if (is_string($number)) {
// 确保字符串是数字
if (!is_numeric($number)) {
throw new InvalidArgumentException("Invalid number format: $number");
}
$number = (float)$number; //转换为float处理
}
return number_format($number, $decimals);
}
// 使用示例
echo formatNumber(1234.567) . PHP_EOL; // 输出: 1,234.57
echo formatNumber("5678.901", 1) . PHP_EOL; // 输出: 5,678.9
echo formatNumber(1000) . PHP_EOL; // 输出: 1,000.00
try {
echo formatNumber("abc"); // 抛出 InvalidArgumentException
} catch (InvalidArgumentException $e) {
echo "Error: " . $e->getMessage() . PHP_EOL;
}
?>在这个例子中，formatNumber 函数的第一个参数 number 被声明为 int|string 类型，表示它可以接受整数或字符串。函数内部使用 is_string 函数来判断参数类型，并进行相应的处理。
2. 函数返回值的联合类型：
假设我们需要编写一个函数，用于从数据库中获取用户信息。如果找到了用户信息，则返回一个关联数组，否则返回 null。
<?php
function getUser(int $userId): array|null {
// 模拟数据库查询
$users = [
1 => ['id' => 1, 'name' => 'Alice'],
2 => ['id' => 2, 'name' => 'Bob'],
];
if (isset($users[$userId])) {
return $users[$userId];
} else {
return null;
}
}
// 使用示例
$user = getUser(1);
if ($user !== null) {
echo "User name: " . $user['name'] . PHP_EOL; // 输出: User name: Alice
} else {
echo "User not found." . PHP_EOL;
}
$user = getUser(3);
if ($user === null) {
echo "User not found." . PHP_EOL; // 输出: User not found.
}
?>在这个例子中，getUser 函数的返回值被声明为 array|null 类型，表示它可以返回一个数组或 null。
3. 类属性的联合类型：
假设我们有一个 Product 类，其中有一个属性 price，可以接受整数或浮点数类型。
<?php
class Product {
public int|float $price;
public function __construct(int|float $price) {
$this->price = $price;
}
public function getPrice(): int|float {
return $this->price;
}
}
// 使用示例
$product1 = new Product(100);
echo "Product 1 price: " . $product1->getPrice() . PHP_EOL; // 输出: Product 1 price: 100
$product2 = new Product(99.99);
echo "Product 2 price: " . $product2->getPrice() . PHP_EOL; // 输出: Product 2 price: 99.99
?>在这个例子中，Product 类的 price 属性被声明为 int|float 类型，表示它可以存储整数或浮点数。
4. 结合 Nullable Types:
联合类型可以与Nullable Types结合使用，表示某个值可以是指定的联合类型之一，也可以是null。 使用 ? 符号来实现，相当于 Type|null 的简写。
<?php
function processName(?string $name): void {
if ($name === null) {
echo "Name is null." . PHP_EOL;
} else {
echo "Name: " . $name . PHP_EOL;
}
}
// 使用示例
processName("John"); // 输出: Name: John
processName(null); // 输出: Name is null.
function getValue(): int|string|null {
// 模拟返回可能为null, string, int 的值
$values = [1, "hello", null];
return $values[array_rand($values)];
}
$value = getValue();
if ($value === null) {
echo "Value is null." . PHP_EOL;
} elseif (is_string($value)) {
echo "Value is a string: " . $value . PHP_EOL;
} elseif (is_int($value)) {
echo "Value is an integer: " . $value . PHP_EOL;
}
?>5. 使用 instanceof 进行类型检查：
当处理联合类型时，可以使用 instanceof 运算符来判断变量的类型，并进行相应的处理。
<?php
class A {}
class B {}
function processObject(A|B $obj): void {
if ($obj instanceof A) {
echo "Object is an instance of A." . PHP_EOL;
} elseif ($obj instanceof B) {
echo "Object is an instance of B." . PHP_EOL;
}
}
// 使用示例
$a = new A();
$b = new B();
processObject($a); // 输出: Object is an instance of A.
processObject($b); // 输出: Object is an instance of B.
?>联合类型和类型检查
PHP 8 对联合类型提供了更严格的类型检查。当传递给函数或赋值给属性的值的类型与声明的联合类型不匹配时，PHP 会抛出一个 TypeError 异常。
<?php
function processData(int|string $data): void {
// ...
}
try {
processData(true); // 抛出 TypeError
} catch (TypeError $e) {
echo "Error: " . $e->getMessage() . PHP_EOL;
}
?>在这个例子中，processData 函数的参数被声明为 int|string 类型，但我们传递了一个布尔值 true，因此 PHP 抛出了一个 TypeError 异常。
这种严格的类型检查可以帮助我们在运行时发现潜在的类型错误，从而提高代码的健壮性。
联合类型与IDE提示
联合类型可以改善IDE的提示效果。当IDE识别到联合类型时，它可以提供更准确的代码补全、错误检测和类型推断。
例如，当我们使用一个支持联合类型的IDE（如PhpStorm）时，当我们调用一个返回联合类型的函数时，IDE会自动提示所有可能的返回类型。
<?php
function getValue(): int|string {
// ...
}
$value = getValue();
// IDE 会提示 $value 可以是 int 或 string 类型
// 我们可以根据 $value 的类型进行相应的处理
if (is_int($value)) {
// ...
} elseif (is_string($value)) {
// ...
}
?>此外，IDE还可以检测到类型错误。如果我们试图将一个不属于联合类型的值赋给一个变量，IDE会发出警告或错误提示。
联合类型与 mixed 类型
mixed 类型表示一个变量可以接受任何类型的值。虽然 mixed 类型也很灵活，但它不如联合类型精确。使用 mixed 类型会牺牲类型检查的严格性，降低代码的健壮性。
<?php
// 使用 mixed 类型
function processValue(mixed $value): void {
// ...
}
// 使用联合类型
function processValue2(int|string $value): void {
// ...
}
?>在上面的例子中，processValue 函数可以接受任何类型的值，但 PHP 不会对传入的值进行类型检查。而 processValue2 函数只能接受整数或字符串类型的值，PHP 会对传入的值进行类型检查。
因此，在可以使用联合类型的情况下，应该尽量避免使用 mixed 类型，以提高代码的健壮性和可读性。
联合类型的限制
虽然联合类型非常强大，但也存在一些限制：
- 不能包含
void类型：void类型表示函数没有返回值，不能与其他类型组合成联合类型。因为void本身就表示没有返回值，所以void|int这样的类型声明是没有意义的。 - 不能包含重复的类型： 联合类型中不能包含重复的类型，例如
int|int是不允许的。 - 不能包含可解析为相同类型的类型： 例如
int|float|double是不允许的，因为double可以解析为float。 - 不能包含伪类型： 伪类型，如
resource，不能用于联合类型。
示例：更复杂的场景
假设我们正在开发一个电商平台，需要处理订单的状态。订单状态可能包括：pending（待处理）、processing（处理中）、shipped（已发货）、delivered（已送达）、cancelled（已取消）。订单状态可以存储为字符串或整数（例如，使用枚举值）。
<?php
class Order {
private string|int $status;
public const STATUS_PENDING = 1;
public const STATUS_PROCESSING = 2;
public const STATUS_SHIPPED = 3;
public const STATUS_DELIVERED = 4;
public const STATUS_CANCELLED = 5;
public function __construct(string|int $status) {
$this->setStatus($status);
}
public function setStatus(string|int $status): void {
if (is_string($status)) {
$allowedStatuses = ['pending', 'processing', 'shipped', 'delivered', 'cancelled'];
if (!in_array($status, $allowedStatuses)) {
throw new InvalidArgumentException("Invalid status: $status");
}
} elseif (is_int($status)) {
$allowedStatuses = [
self::STATUS_PENDING,
self::STATUS_PROCESSING,
self::STATUS_SHIPPED,
self::STATUS_DELIVERED,
self::STATUS_CANCELLED,
];
if (!in_array($status, $allowedStatuses)) {
throw new InvalidArgumentException("Invalid status code: $status");
}
} else {
throw new TypeError("Status must be a string or an integer.");
}
$this->status = $status;
}
public function getStatus(): string|int {
return $this->status;
}
public function getStatusDescription(): string {
$status = $this->getStatus();
if (is_string($status)) {
return match ($status) {
'pending' => '待处理',
'processing' => '处理中',
'shipped' => '已发货',
'delivered' => '已送达',
'cancelled' => '已取消',
default => '未知状态',
};
} elseif (is_int($status)) {
return match ($status) {
self::STATUS_PENDING => '待处理',
self::STATUS_PROCESSING => '处理中',
self::STATUS_SHIPPED => '已发货',
self::STATUS_DELIVERED => '已送达',
self::STATUS_CANCELLED => '已取消',
default => '未知状态',
};
}
return '未知状态'; //理论上不可能执行到这里
}
}
// 使用示例
$order1 = new Order('pending');
echo "Order 1 status: " . $order1->getStatusDescription() . PHP_EOL; // 输出: Order 1 status: 待处理
$order2 = new Order(Order::STATUS_SHIPPED);
echo "Order 2 status: " . $order2->getStatusDescription() . PHP_EOL; // 输出: Order 2 status: 已发货
try {
$order3 = new Order('invalid'); // 抛出 InvalidArgumentException
} catch (InvalidArgumentException $e) {
echo "Error: " . $e->getMessage() . PHP_EOL;
}
?>在这个例子中，Order 类的 status 属性被声明为 string|int 类型，表示它可以存储字符串或整数类型的订单状态。setStatus 方法会根据传入的类型进行验证，确保状态值是有效的。
关于性能的考量
虽然联合类型带来了诸多好处，但我们也需要考虑其对性能的影响。在某些情况下，使用联合类型可能会导致一些性能开销，因为 PHP 需要在运行时检查变量的类型。然而，这种性能开销通常是可以忽略不计的，尤其是在大多数应用程序中。
如果对性能有非常严格的要求，可以考虑使用更具体的类型声明，或者使用性能分析工具来评估联合类型对性能的影响。
使用联合类型可以提高代码质量
PHP 8 的联合类型是一个强大的特性，它可以帮助我们编写更加清晰、健壮和可维护的代码。通过更准确的类型声明和更严格的类型检查，我们可以减少因类型错误导致的 bug，并提高代码的质量。此外，联合类型还可以改善 IDE 的提示效果，提高开发效率。在实际开发中，我们应该充分利用联合类型，并结合其他类型提示特性，编写高质量的 PHP 代码。
类型信息更加清晰，代码更加健壮
总而言之，PHP 8 的联合类型为我们提供了一种更灵活、更强大的类型声明方式。通过使用联合类型，我们可以更清晰地表达变量或函数参数可能接受的类型，从而提高代码的健壮性和可读性。同时，IDE 可以更好地理解联合类型，提供更准确的代码补全和错误检测，从而提高开发效率。