PHP7 模块化编程（一）
原文：
zh.annas-archive.org/md5/ff0acc039cf922de0886cd9283ec3d9f译者：飞龙
前言
构建模块化应用程序是一项具有挑战性的任务。它涉及广泛的知识领域，从设计模式和原则到所选择技术栈的方方面面。PHP 生态系统有相当多的工具、库、框架和平台，可以帮助我们实现模块化应用程序开发的目标。
PHP 7 带来了许多改进，可以进一步帮助实现这一目标。我们将从这些改进中开始我们的旅程。在本书结束时，我们的最终交付物将是一个由 Symfony 框架构建的模块化网络商店应用程序。
本书内容
第一章，生态系统概述，对 PHP 生态系统的当前状态进行了简要介绍。它探讨了 PHP 7 的最新功能，其中一些功能为模块化开发中的新概念打开了大门。此外，本章还概述了流行的 PHP 框架。
第二章，GoF 设计模式，描述了软件设计中常见问题的重复解决方案。为以下每种模式提供了实际的 PHP 示例：创建模式类型、结构模式和行为模式。
第三章，SOLID 设计原则，深入探讨了面向对象编程和设计的五个基本原则，这些原则使用 SOLID（单一责任、开闭原则、里氏替换、接口隔离和依赖反转）的首字母缩写。它提供了实际示例，并解释了这些原则在模块化开发中的重要性。
第四章，模块化网络商店应用的需求规范，指导读者定义整体应用程序需求的过程。它从定义实际应用程序功能需求开始，并逐步进行技术栈选择。
第五章，Symfony 概述，对 Symfony 作为框架、一组工具和开发方法论进行了高层次的概述。它侧重于我们构建模块化应用程序所需的构建模块。
第六章，构建核心模块，指导您通过基于 Symfony 捆绑包设置核心模块。然后，核心模块用于为其他模块设置结构和依赖关系。
第七章，构建目录模块，指导我们通过构建一个与网络商店仅目录功能集相匹配的自给模块。它向我们展示了如何设置与模块功能相关的实体，以及如何使用现有框架管理这些实体及其交互。
第八章，构建客户模块，指导我们通过构建一个与网络商店客户相关的功能集相匹配的自给模块。它向我们展示了如何设置与模块功能相关的实体，以及如何使用现有框架管理这些实体及其交互。它进一步向我们展示了如何创建注册和登录系统。
第九章，构建支付模块，指导我们通过构建一个与网络商店支付相关的功能集相匹配的自给模块。它向我们展示了如何与第三方支付提供商集成。它进一步向我们展示了如何将支付提供商作为服务提供给其他模块使用。
第十章，“构建发货模块”，指导我们构建一个自给自足的模块，与网店的发货相关功能相匹配。它向我们展示了如何定义几个扁平方法，根据不同的购物车产品属性产生不同的发货定价。它进一步向我们展示了如何将发货方法公开为其他模块使用的服务。
第十一章，“构建销售模块”，指导我们构建一个自给自足的模块，与网店仅销售相关的功能集相匹配。它向我们展示了如何设置与模块功能相关的购物车、购物车项目、订单和订单项目实体，以及如何使用现有框架管理这些实体及其交互。
第十二章，“集成和分发模块”，将前几章中构建的所有模块集成到一个单一的功能应用程序中。接下来，它指导我们通过现代 PHP 模块分发技术。这些技术包括 Git 和 Composer，间接包括 GitHub 和 Packagist。
您需要什么
为了成功运行本书提供的所有示例，您需要自己的 Web 服务器或第三方 Web 托管解决方案。高级技术栈包括 PHP 7.0 或更高版本，Apache/Nginx 和 MySQL。
Symfony 框架本身带有详细的系统要求列表，可以在symfony.com/doc/current/reference/requirements.html找到。
本书假设读者熟悉设置完整的开发环境。
本书的受众
本书主要面向中级 PHP 开发人员，他们对模块化编程几乎没有了解，希望了解设计模式和原则，以更好地利用现有框架进行模块化应用程序开发。
本书开发的模块化网店应用程序使用 Symfony 框架。但是，不需要假设或要求对 Symfony 框架有任何先前的了解。
约定
在本书中，您会发现一些区分不同类型信息的文本样式。以下是一些这些样式的示例及其含义的解释。
文本中的代码词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 句柄显示如下：“我们可以通过使用include指令包含其他上下文。”
代码块设置如下：
function hint (int $A, float $B, string $C, bool $D)
{
var_dump($A, $B, $C, $D);
}
任何命令行输入或输出都以以下形式编写：
**sudo curl -LsS https://symfony.com/installer -o /usr/local/bin/symfony**
**sudo chmod a+x /usr/local/bin/symfony**
新术语和重要单词以粗体显示。您在屏幕上看到的单词，例如菜单或对话框中的单词，会出现在文本中，如：“单击下一步按钮将您移至下一个屏幕。”
注意
警告或重要说明会出现在这样的框中。
提示
技巧和窍门会以这种方式出现。
第一章：生态系统概述
自 PHP 诞生以来已经过去了二十多年。最初由 Rasmus Lerdorf 于 1994 年创建，PHP 首字母缩略词最初代表个人主页。当时，PHP 只是用于支持简单网页的几个公共网关接口（CGI）程序。
尽管 PHP 并不打算成为一种新的编程语言，但这个想法却得到了认可。在 90 年代末，Zend Technologies 的联合创始人 Zeev Suraski 和 Andi Gutmans 通过重写整个解析器继续了 PHP 的工作，从而诞生了 PHP 3。PHP 语言名称首字母缩略词现在代表PHP：超文本预处理器。
PHP 将自己定位在世界前十大编程语言之中。根据软件质量公司 TIOBE 的数据，它目前排名第六。特别是自 2004 年 7 月发布 PHP 5 以来的最后十年中，PHP 一直被认为是构建 Web 应用程序的热门解决方案。
尽管 PHP 仍然表现为一种脚本语言，但可以肯定的是，自 PHP 5 以来，它已经远远超出了这一范畴。像 WordPress、Drupal、Magento 和 PrestaShop 等世界上最受欢迎的平台都是用 PHP 构建的。正是这些项目进一步提高了 PHP 的受欢迎程度。其中一些项目通过实现其他编程语言（如 Java、C＃）和它们的框架中找到的复杂 OOP（面向对象编程）设计模式来拓展 PHP 的边界。
尽管 PHP 5 具有不错的面向对象编程（OOP）支持，但仍有许多事情有待实现。PHP 6 的工作计划是为 PHP Unicode 字符串提供更多支持。遗憾的是，它的开发停滞不前，PHP 6 在 2010 年被取消了。
同年，Facebook 宣布了他们的 HipHop 编译器。他们的编译器将 PHP 代码转换为 C++代码。然后通过 C++编译器将 C++代码进一步编译成本机代码。这个概念为 PHP 带来了重大的性能改进。然而，这种方法并不是很实用，因为将 PHP 脚本编译成本机代码太耗时。
不久之后，Zend Technologies 首席性能工程师 Dmitry Stogov 宣布了一个名为PHPNG的项目，这成为了下一个 PHP 版本 PHP 7 的基础。
2015 年 12 月，PHP 7 发布，带来了许多改进和新功能：
-
Zend Engine 的新版本
-
性能提升（比 PHP 5.6 快两倍）
-
显著减少的内存使用
-
抽象语法树
-
一致的 64 位支持
-
改进的异常层次结构
-
许多致命错误转换为异常
-
安全随机数生成器
-
删除了旧的和不受支持的 SAPI 和扩展
-
空合并运算符
-
返回和标量类型声明
-
匿名类
-
零成本断言
在本章中，我们将讨论以下主题：
-
为 PHP 7 做好准备
-
框架
为 PHP 7 做好准备
PHP 7 带来了一系列重大变化。这些变化影响了 PHP 解释器以及各种扩展和库。尽管大多数 PHP 5 代码在 PHP 7 解释器上仍将继续正常运行，但了解新提供的功能是值得的。
接下来，我们将研究其中一些功能及其提供的好处。
标量类型提示
标量类型提示在 PHP 中并不是一个全新的功能。随着 PHP 5.0 的引入，我们获得了对类和接口的类型提示的能力。PHP 5.1 通过引入数组类型提示来扩展了这一功能。随后，PHP 5.4 还额外增加了对可调用类型的提示。最后，PHP 7 引入了标量类型提示。将类型提示扩展到标量使得这可能是 PHP 7 中添加的最令人兴奋的功能之一。
现在可用的标量类型提示如下：
-
string：字符串（例如，hello，foo和bar） -
int：整数（例如，1，2和3） -
float：浮点数（例如，1.2，2.4和5.6） -
bool：布尔值（例如，true或false）
默认情况下，PHP 7 以弱类型检查模式工作，并将尝试转换为指定类型而不投诉。我们可以使用strict_typesdeclare()指令来控制这种模式。
declare(strict_types=1);指令必须是文件中的第一条语句，否则会生成编译器错误。它只影响它所在的特定文件，并不影响其他包含的文件。该指令完全是编译时的，不能在运行时控制。
declare(strict_types=0); //weak type-checking
declare(strict_types=1); // strict type-checking
假设以下是一个接受标量类型提示的简单函数。
function hint (int $A, float $B, string $C, bool $D)
{
var_dump($A, $B, $C, $D);
}
新标量类型声明的弱类型检查规则大多与扩展和内置 PHP 函数的规则相同。由于这种自动转换，当将数据传递给函数时，我们可能会不知不觉地丢失数据。一个简单的例子是将浮点数传递给需要整数的函数；在这种情况下，转换将简单地去掉小数部分。
假设弱类型检查是打开的，默认情况下，可以观察到以下情况：
hint(2, 4.6, 'false', true);
/* int(2) float(4.6) string(5) "false" bool(true) */
hint(2.4, 4, true, 8);
/* int(2) float(4) string(1) "1" bool(true) */
我们可以看到第一个函数调用按照提示传递参数。第二个函数调用并没有传递确切类型的参数，但函数仍然能够执行，因为参数经过了转换。
假设弱类型检查关闭，通过使用declare(strict_types=1);指令，可以观察到以下情况：
hint(2.4, 4, true, 8);
Fatal error: Uncaught TypeError: Argument 1 passed to hint() must be of the type integer, float given, called in php7.php on line 16 and defined in php7.php:8 Stack trace: #0 php7.php(16): hint(2.4, 4, true, 8) #1 {main} thrown in php7.php on line 8
函数调用在第一个参数上中断，导致\TypeError异常。strict_types=1指令不允许任何类型转换。参数必须与函数定义提示的类型相同。
返回类型提示
除了类型提示，我们还可以对返回值进行类型提示。所有可以应用于函数参数的类型提示都可以应用于函数返回值。这也适用于弱类型检查规则。
要添加返回类型提示，只需在参数列表后面加上冒号和返回类型，如下例所示：
function divide(int $A, int $B) : int
{
return $A / $B;
}
前面的函数定义表示divide函数期望两个int类型的参数，并且应该返回一个int类型的参数。
假设弱类型检查是打开的，默认情况下，可以观察到以下情况：
var_dump(divide(10, 2)); // int(5)
var_dump(divide(10, 3)); // int(3)
虽然divide(10, 3)的实际结果应该是一个浮点数，但返回类型提示会触发转换为整数。
假设弱类型检查关闭，通过使用declare(strict_types=1);指令，可以观察到以下情况：
int(5)
Fatal error: Uncaught TypeError: Return value of divide() must be of the type integer, float returned in php7.php:10 Stack trace: #0php7.php(14): divide(10, 3) #1 {main} thrown in php7.php on line 10
在放置strict_types=1指令的情况下，divide(10, 3)会失败并抛出\TypeError异常。
提示
使用标量类型提示和返回类型提示可以提高我们的代码可读性，以及像 NetBeans 和 PhpStorm 这样的 IDE 编辑器的自动完成功能。
匿名类
随着匿名类的添加，PHP 对象获得了类似闭包的能力。我们现在可以通过无名类实例化对象，这使我们更接近其他语言中的对象文字语法。让我们看一个简单的例子：
$object = new class {
public function hello($message) {
return "Hello $message";
}
};
echo$object->hello('PHP');
前面的例子显示了一个$object变量存储了一个匿名类实例的引用。更可能的用法是直接将新类传递给函数参数，而不将其存储为变量，如下所示：
$helper->sayHello(new class {
public function hello($message) {
return "Hello $message";
}
});
与任何普通类一样，匿名类可以将参数传递给它们的构造函数，扩展其他类，实现接口，并使用特征：
class TheClass {}
interface TheInterface {}
trait TheTrait {}
$object = new class('A', 'B', 'C') extends TheClass implements TheInterface {
use TheTrait;
public $A;
private $B;
protected $C;
public function __construct($A, $B, $C)
{
$this->A = $A;
$this->B = $B;
$this->C = $C;
}
};
var_dump($object);
上面的例子将输出：
object(class@anonymous)#1 (3) { ["A"]=> string(1) "A"["B":"class@anonymous":private]=> string(1) "B"["C":protected]=> string(1) "C" }
匿名类的内部名称是根据其地址生成的唯一引用。
关于何时使用匿名类并没有明确的答案。这几乎完全取决于我们正在构建的应用程序，以及对象，根据它们的视角和用法。
使用匿名类的一些好处如下：
-
模拟应用程序测试变得微不足道。我们可以为接口创建临时实现，避免使用复杂的模拟 API。
-
避免为了更简单的实现而经常调用自动加载程序。
-
清楚地告诉任何阅读代码的人，这个类在这里使用，而不是其他地方。
匿名类，或者说从匿名类实例化的对象，不能被序列化。尝试对它们进行序列化会导致致命错误，如下所示：
Fatal error: Uncaught Exception: Serialization of 'class@anonymous' is not allowed in php7.php:29 Stack trace: #0 php7.php(29): serialize(Object(class@anonymous)) #1 {main} thrown in php7.php on line 29
嵌套的匿名类不能访问外部类的私有或受保护的方法和属性。为了使用外部类的受保护方法和属性，匿名类可以扩展外部类。忽略方法，外部类的私有或受保护属性可以在匿名类中使用，如果通过其构造函数传递：
class Outer
{
private $prop = 1;
protected $prop2 = 2;
protected function outerFunc1()
{
return 3;
}
public function outerFunc2()
{
return new class($this->prop) extends Outer
{
private $prop3;
public function __construct($prop)
{
$this->prop3 = $prop;
}
public function innerFunc1()
{
return $this->prop2 + $this->prop3 + $this->outerFunc1();
}
};
}
}
echo (new Outer)->outerFunc2()->innerFunc1(); //6
尽管我们将它们标记为匿名类，但从这些类实例化的对象的内部名称实际上并不是匿名的。匿名类的内部名称是根据其地址生成的唯一引用。
语句get_class(new class{});将导致类似class@anonymous/php7.php0x7f33c22381c8的结果，其中0x7f33c22381c8是内部地址。如果我们在代码的其他地方定义完全相同的匿名类，它的类名将不同，因为它将分配不同的内存地址。在这种情况下，结果对象可能具有相同的属性值，这意味着它们将相等（==）但不是相同的（===）。
Closure::call()方法
PHP 在 5.3 版本中引入了 Closure 类。Closure 类用于表示匿名函数。在 PHP 5.3 中实现的匿名函数产生了这种类型的对象。从 PHP 5.4 开始，Closure 类获得了几种方法（bind、bindTo），允许在创建匿名函数后进一步控制匿名函数。这些方法基本上是使用特定绑定对象和类范围复制闭包。PHP 7 在 Closure 类上引入了call方法。call方法不会复制闭包，它会临时将闭包绑定到新的 this（$newThis），并使用任何给定的参数调用它。然后返回闭包的返回值。
call函数签名如下：
function call ($newThis, ...$parameters) {}
parameters 给闭包的参数是可选的，意味着可以是零个或多个。
让我们看一个简单的Customer类和一个$greeting闭包的以下示例：
class Customer {
private $firstname;
private $lastname;
public function __construct($firstname, $lastname)
{
$this->firstname = $firstname;
$this->lastname = $lastname;
}
}
$customer = new Customer('John', 'Doe');
$greeting = function ($message) {
return "$message $this->firstname $this->lastname!";
};
echo **$greeting->call($customer, 'Hello');**
在实际的$greeting闭包中，没有$this，直到实际绑定发生之前它都不存在。我们可以通过直接调用像$greeting('Hello');这样的闭包来轻松确认这一点。但是，我们假设当我们通过其call函数将闭包绑定到给定对象实例时，$this将出现。在这种情况下，闭包中的$this变成了customer对象实例的$this。前面的示例显示了使用call方法调用将$customer绑定到闭包的绑定。生成的输出显示Hello John Doe!
生成器委托
生成器提供了一种简单的方法来实现迭代器，而无需实现实现Iterator接口的类的开销。它们允许我们编写使用foreach来迭代一组数据的代码，而无需在内存中构建数组。这消除了超出内存限制的错误。它们对于 PHP 并不是新的，因为它们是在 PHP 5.5 中添加的。
然而，PHP 7 为生成器带来了几项新的改进，其中之一是生成器委托。
生成器委托允许生成器产生其他生成器、数组或实现Traversable接口的对象。换句话说，我们可以说生成器委托是产生子生成器。
让我们看一个带有三个生成器类型函数的以下示例：
function gen1() {
yield '1';
yield '2';
yield '3';
}
function gen2() {
yield '4';
yield '5';
yield '6';
}
function gen3() {
yield '7';
yield '8';
**yield from gen1();**
yield '9';
**yield from gen2();**
yield '10';
}
// output of the below code: 123
foreach (gen1() as $number) {
echo $number;
}
//output of the below code: 78123945610
foreach (gen3() as $number) {
echo $number;
}
产生其他生成器需要使用yield from <expression>语法。
生成器返回表达式
在 PHP 7 之前，生成器函数无法返回表达式。生成器函数无法指定返回值的能力限制了它们在协程上下文中的实用性。
PHP 7 使生成器能够返回表达式。现在我们可以调用 $generator->getReturn() 来检索 return 表达式。当生成器尚未返回或抛出未捕获的异常时调用 $generator->getReturn() 将抛出异常。
如果生成器没有定义返回表达式并且已经完成了产出，将返回 null。
让我们看下面的例子：
function gen() {
yield 'A';
yield 'B';
yield 'C';
return 'gen-return';
}
$generator = gen();
//output of the below code: object(Generator)#1 (0) { }
var_dump($generator);
// output of the below code: Fatal error
// var_dump($generator->getReturn());
// output of the below code: ABC
foreach ($generator as $letter) {
echo $letter;
}
// string(10) "gen-return"
var_dump($generator->getReturn());
看看 gen() 函数定义及其 return 表达式，人们可能期望 $generator 变量的值等于 gen-return 字符串。然而，情况并非如此，因为 $generator 变量变成了 \Generator 类的实例。在生成器仍然打开（未迭代）时调用生成器上的 getReturn() 方法将导致致命错误。
如果代码的结构使得不明显生成器是否已关闭，我们可以使用 valid 方法在获取返回值之前进行检查：
if ($generator->valid() === false) {
var_dump($generator->getReturn());
}
空合并运算符
在 PHP 5 中，我们有三元运算符，它测试一个值，然后如果该值为 true，则返回第二个元素，如果该值为 false，则返回第三个元素，如下面的代码块所示：
$check = (5 > 3) ? 'Correct!' : 'Faulty!'; // Correct!
$check = (5 < 3) ? 'Correct!' : 'Faulty!'; // Faulty!
在处理 PHP 等网络中心语言中的用户提供的数据时，通常会检查变量是否存在。如果变量不存在，则将其设置为某个默认值。三元运算符为我们提供了这种便利，如下所示：
$role = isset($_GET['role']) ? $_GET['role'] : 'guest';
然而，简单并不总是快速或优雅。考虑到这一点，PHP 7 旨在解决最常见的用法模式之一，引入了空合并运算符(??)。
空合并运算符使我们能够编写更短的表达式，如下面的代码块中所示：
$role = $_GET['role'] **??**'guest';
合并运算符(??)被添加到 $_GET['role'] 变量之后，如果第一个操作数存在且不为 NULL，则返回第一个操作数的结果，否则返回第二个操作数的结果。这意味着 $_GET['role'] ?? 'guest' 是完全安全的，不会引发 E_NOTICE。
我们还可以嵌套使用合并运算符：
$A = null; // or not set
$B = 10;
echo $A ?? 20; // 20
echo $A ?? $B ?? 30; // 10
从左到右阅读，存在且不为 null 的第一个值将被返回。这种构造的好处在于它能够以一种清晰有效的方式实现对所需值的安全回退。
提示
该书的代码包也托管在 GitHub 上，网址为 github.com/PacktPublishing/Modular-Programming-with-PHP7。我们还有其他丰富的书籍和视频代码包可供查阅，网址为 github.com/PacktPublishing/。欢迎查看！
太空船运算符
三向比较运算符，也称为太空船运算符，是在 PHP 7 中引入的。其语法如下：
(expr) <=> (expr)
如果两个操作数相等，则运算符返回 0，如果左边大，则返回 1，如果右边大，则返回 -1。
它使用与其他现有比较运算符相同的比较规则：<、<=、==、>= 和 >。
operator<=> equivalent
$a < $b($a <=> $b) === -1
$a <= $b($a <=> $b) === -1 || ($a <=> $b) === 0
$a == $b($a <=> $b) === 0
$a != $b($a <=> $b) !== 0
$a >= $b($a <=> $b) === 1 || ($a <=> $b) === 0
$a > $b($a <=> $b) === 1
以下是一些太空船运算符行为的示例：
// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
// Strings
echo "a"<=>"a"; // 0
echo "a"<=>"b"; // -1
echo "b"<=>"a"; // 1
echo "a"<=>"aa"; // -1
echo "zz"<=>"aa"; // 1
// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1
// Objects
$a = (object) ["a" =>"b"];
$b = (object) ["a" =>"b"];
echo $a <=> $b; // 0
$a = (object) ["a" =>"b"];
$b = (object) ["a" =>"c"];
echo $a <=> $b; // -1
$a = (object) ["a" =>"c"];
$b = (object) ["a" =>"b"];
echo $a <=> $b; // 1
// only values are compared
$a = (object) ["a" =>"b"];
$b = (object) ["b" =>"b"];
echo $a <=> $b; // 0
这个运算符的一个实际用例是编写在排序函数中使用的回调，比如 usort、uasort 和 uksort：
$letters = ['D', 'B', 'A', 'C', 'E'];
usort($letters, function($a, $b) {
return $a <=> $b;
});
var_dump($letters);
// array(5) { [0]=> string(1) "A" [1]=> string(1) "B" [2]=>string(1) "C" [3]=> string(1) "D" [4]=> string(1) "E" }
可抛出对象
尽管 PHP 5 引入了异常模型，但整体错误和错误处理仍然有些粗糙。基本上，PHP 有两种错误处理系统。传统错误仍然会弹出，并且不会被 try…catch 块处理。
以 E_RECOVERABLE_ERROR 为例：
class Address
{
private $customer;
public function __construct(Customer $customer)
{
$this->customer = $customer;
}
}
$customer = new stdClass();
try {
$address = new Address($customer);
} catch (\Exception $e) {
echo 'handling';
} finally {
echo 'cleanup';
}
在这里，try…catch 块没有效果，因为错误不被解释为异常，而是可捕获的致命错误：
Catchable fatal error: Argument 1 passed to Address::__construct() must be an instance of Customer, instance of stdClass given, called in script.php on line 15 and defined in script.php on line 6.
一种可能的解决方法是使用 set_error_handler 函数设置用户定义的错误处理程序，如下所示：
set_error_handler(function($code, $message) {
throw new \Exception($message, $code);
});
如上所述，错误处理程序现在会将每个错误转换为异常，因此可以通过try…catch块捕获。
PHP 7 将致命错误和可捕获的致命错误作为引擎异常的一部分，因此可以通过try…catch块捕获。这不包括警告和通知，它们仍然不通过异常系统，这对于向后兼容性是有意义的。
它还通过\Throwable接口引入了一个新的异常层次结构。\Exception和\Error实现了\Throwable接口。
标准的 PHP 致命错误和可捕获的致命错误现在作为\Error异常抛出，尽管如果它们未被捕获，它们仍将继续触发传统的致命错误。
在整个应用程序中，我们必须使用\Exception和\Error，因为我们不能直接实现\Throwable接口。但是，我们可以使用以下块来捕获所有错误，无论是\Exception还是\Error类型：
try {
// statements
} catch (**\Throwable $t**) {
// handling
} finally {
// cleanup
}
\ParseError
ParseError是 PHP 7 对错误处理的一个很好的补充。我们现在可以处理由eval()、include和require语句触发的解析错误，以及由\ParseError异常抛出的解析错误。它扩展了\Error，而\Error又实现了\Throwable接口。
以下是一个破损的 PHP 文件的示例，因为数组项之间缺少“,”：
<?php
$config = [
'host' =>'localhost'
'user' =>'john'
];
return $config;
以下是包括config.php的文件的示例：
<?php
try {
include 'config.php';
} catch (\ParseError $e) {
// handle broken file case
}
我们现在可以安全地捕获可能的解析错误。
dirname()函数的级别支持
dirname函数自 PHP 4 以来一直存在。这可能是 PHP 中最常用的函数之一。直到 PHP 7，此函数只接受path参数。在 PHP 7 中，添加了新的 levels 参数。
让我们看下面的例子：
// would echo '/var/www/html/app/etc'
echo dirname('/var/www/html/app/etc/config/');
// would echo '/var/www/html/app/etc'
echo dirname('/var/www/html/app/etc/config.php');
// would echo '/var/www/html/app'
echo dirname('/var/www/html/app/etc/config.php', 2);
// would echo '/var/www/html'
echo dirname('/var/www/html/app/etc/config.php', 3);
通过分配levels值，我们指示从分配的路径值向上移动多少级。虽然很小，但levels参数的添加肯定会使处理路径的某些代码更容易编写。
整数除法函数
intdiv是 PHP 7 引入的新的整数除法函数。该函数接受被除数和除数作为参数，并返回它们的商的整数部分，如下面的函数描述所示：
int intdiv(int $dividend, int $divisor)
让我们看下面的几个例子：
intdiv(5, 3); // int(1)
intdiv(-5, 3); // int(-1)
intdiv(5, -2); // int(-2)
intdiv(-5, -2); // int(2)
intdiv(PHP_INT_MAX, PHP_INT_MAX); // int(1)
intdiv(PHP_INT_MIN, PHP_INT_MIN); // int(1)
// following two throw error
intdiv(PHP_INT_MIN, -1); // ArithmeticError
intdiv(1, 0); // DivisionByZeroError
如果dividend是PHP_INT_MIN，而除数是-1，那么会抛出ArithmeticError异常。如果除数是0，那么会抛出DivisionByZeroError异常。
常量数组
在 PHP 7 之前，使用define()定义的常量只能包含标量表达式，而不能包含数组。从 PHP 5.6 开始，可以使用const关键字定义数组常量，从 PHP 7 开始，也可以使用define()定义数组常量：
// the define() example
define('FRAMEWORK', [
'version' => 1.2,
'licence' =>'enterprise'
]);
echo FRAMEWORK['version']; // 1.2
echo FRAMEWORK['licence']; // enterprise
// the class const example
class App {
const FRAMEWORK = [
'version' => 1.2,
'licence' =>'enterprise'
];
}
echo App::FRAMEWORK['version']; // 1.2
echo App::FRAMEWORK['licence']; // enterprise
常量一旦设置后就不能重新定义或取消定义。
统一的变量语法
为了使 PHP 的解析器更完整，PHP 7 引入了统一的变量语法。使用统一的变量语法，所有变量都是从左到右进行评估的。
与删除各种函数、关键字或设置不同，像这样的语义变化对现有代码库的影响可能相当大。以下代码演示了语法、其旧含义和新含义：
// Syntax
$$foo['bar']['baz']
// PHP 5.x:
// Using a multidimensional array value as variable name
${$foo['bar']['baz']}
// PHP 7:
// Accessing a multidimensional array within a variable-variable
($$foo)['bar']['baz']
// Syntax
$foo->$bar['baz']
// PHP 5.x:
// Using an array value as a property name
$foo->{$bar['baz']}
// PHP 7:
// Accessing an array within a variable-property
($foo->$bar)['baz']
// Syntax
$foo->$bar['baz']()
// PHP 5.x:
// Using an array value as a method name
$foo->{$bar['baz']}()
// PHP 7:
// Calling a closure within an array in a variable-property
($foo->$bar)['baz']()
// Syntax
Foo::$bar['baz']()
// PHP 5.x:
// Using an array value as a static method name
Foo::{$bar['baz']}()
// PHP 7:
// Calling a closure within an array in a static variable
(Foo::$bar)['baz']()
除了以前重写的旧到新语法示例之外，现在还支持一些新的语法组合。
PHP 7 现在支持嵌套双冒号::，以下是一个示例：
// Access a static property on a string class name
// or object inside an array
$foo['bar']::$baz;
// Access a static property on a string class name or object
// returned by a static method call on a string class name
// or object
$foo::bar()::$baz;
// Call a static method on a string class or object returned by
// an instance method call
$foo->bar()::baz();
我们还可以通过在括号中加倍来嵌套方法和函数调用，或者任何可调用的内容，如下面的代码示例所示：
// Call a callable returned by a function
foo()();
// Call a callable returned by an instance method
$foo->bar()();
// Call a callable returned by a static method
Foo::bar()();
// Call a callable return another callable
$foo()();
此外，我们现在可以对任何用括号括起来的有效表达式进行解引用：
// Access an array key
(expression)['foo'];
// Access a property
(expression)->foo;
// Call a method
(expression)->foo();
// Access a static property
(expression)::$foo;
// Call a static method
(expression)::foo();
// Call a callable
(expression)();
// Access a character
(expression){0};
安全的随机数生成器
PHP 7 引入了两个新的CSPRNG函数。CSPRNG 是密码学安全伪随机数生成器的缩写。
第一个random_bytes生成一个任意长度的加密随机字节字符串，适用于加密用途，比如生成盐、密钥或初始化向量。该函数只接受一个（length）参数，表示应以字节返回的随机字符串的长度。它返回一个包含请求的数量的密码安全随机字节的字符串，或者在找不到适当的随机源时，它会抛出一个异常。
以下是random_bytes的使用示例：
$bytes = random_bytes(5);
第二个random_int生成适用于需要无偏结果的密码随机整数，比如在为扑克游戏洗牌时。该函数接受两个（min，max）参数，表示要返回的最小值（必须是PHP_INT_MIN或更高）和要返回的最大值（必须小于或等于PHP_INT_MAX）。它返回范围在 min 到 max（包括 min 和 max）之间的密码安全随机整数。
以下是random_int的使用示例：
$int = random_int(1, 10);
$int = random_int(PHP_INT_MIN, 500);
$int = random_int(20, PHP_INT_MAX);
$int = random_int(PHP_INT_MIN, PHP_INT_MAX);
过滤反序列化()
序列化数据可以包括对象。这些对象还可以包括析构函数、__toString和__call等函数。为了在对非结构化数据上反序列化对象时提高安全性，PHP 7 引入了现有unserialize函数的可选options参数。
options参数是一个数组类型，目前只接受allowed_classes键。
allowed_classes可以有三个值之一：
-
true：这是默认值，和以前一样允许所有对象 -
false：这里不允许对象 -
允许的类名数组，列出了未序列化对象的允许类
以下是使用allowed_classes选项的示例：
class Customer{
public function __construct(){
echo '__construct';
}
public function __destruct(){
echo '__destruct';
}
public function __toString(){
echo '__toString';
return '__toString';
}
public function __call($name, $arguments) {
echo '__call';
}
}
$customer = new Customer();
$s = serialize($customer); // triggers: __construct, __destruct
$u = unserialize($s); // triggers: __destruct
echo get_class($u); // Customer
$u = unserialize($s, ['allowed_classes'=>false]); // does not trigger anything
echo get_class($u); // __PHP_Incomplete_Class
我们可以看到，该类的对象如果不被接受，则被实例化为__PHP_Incomplete_Class。
上下文敏感的词法分析器
根据php.net/manual/en/reserved.keywords.php列表，PHP 有 60 多个保留关键字。这些构成了语言结构，比如类、接口和特征中的属性、方法、常量的名称。
有时这些保留字最终会与用户定义的 API 声明发生冲突。
为了解决这个问题，PHP 7.0 引入了上下文敏感的词法分析器。有了上下文敏感的词法分析器，我们现在可以在我们的代码中使用关键字来表示属性、函数和常量的名称。
以下是与上下文敏感的词法分析器的影响相关的一些实际示例：
class ReportPool {
public function include(Report $report) {
//
}
}
$reportPool = new ReportPool();
$reportPool->include(new Report());
class Collection extends \ArrayAccess, \Countable, \IteratorAggregate {
public function forEach(callable $callback) {
//
}
public function list() {
//
}
public static function new(array $items) {
return new self($items);
}
}
Collection::new(['var1', 'var2'])
->forEach(function($index, $item){ /* ... */ })
->list();
唯一的例外是class关键字，在类常量上下文中仍然保留，如下所示：
class Customer {
const class = 'Retail'; // Fatal error
}
组使用声明
组使用声明在 PHP 7 中引入，用于从公共命名空间导入多个类时减少冗长。它们启用了如下的简写语法：
use Library\Group1\Group2\{ ClassA, ClassB, ClassC as Classy };
让我们看一下下面的例子，其中相同命名空间内的类名被组合使用：
// Current use syntax
use Doctrine\Common\Collections\Expr\Comparison;
use Doctrine\Common\Collections\Expr\Value;
use Doctrine\Common\Collections\Expr\CompositeExpression;
// Group use syntax
use Doctrine\Common\Collections\Expr\{ Comparison, Value, CompositeExpression };
我们还可以在部分命名空间上使用组使用声明，如下面的示例所示：
// Current use syntax
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\NullOutput;
use Symfony\Component\Console\Question\Question;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Question\ChoiceQuestion as Choice;
use Symfony\Component\Console\Question\ConfirmationQuestion;
// Group use syntax
use Symfony\Component\Console\{
Helper\Table,
Input\ArrayInput,
Input\InputInterface,
Output\NullOutput,
Output\OutputInterface,
Question\Question,
Question\ChoiceQuestion as Choice,
Question\ConfirmationQuestion,
};
我们还可以像下面的代码行一样进一步使用group use来导入函数和常量：
use Framework\Component\{
SubComponent\ClassA,
function OtherComponent\someFunction,
const OtherComponent\SOME_CONSTANT
};
Unicode 增强
Unicode，特别是 UTF-8，在 PHP 应用程序中越来越受欢迎。
PHP 7 为双引号字符串和heredocs添加了新的转义序列，语法如下：
\u{code-point}
它产生了一个 Unicode 代码点的 UTF-8 编码，用十六进制数字指定。值得注意的是，花括号中的代码点长度是任意的。这意味着我们可以使用\u{FF}或更传统的\u{00FF}。
以下是四种最常用货币、它们的符号和它们的 UTF-8 代码点的简单列表：
Euro€U+20AC
Japanese Yen¥U+00A5
Pound sterling£U+00A3
Australian dollar$U+0024
其中一些符号通常直接存在于键盘上，所以很容易像这里显示的那样写下来：
echo "the € currency";
echo "the ¥ currency";
echo "the £ currency";
echo "the $ currency";
然而，大多数其他符号不像单个按键那样容易访问，因此需要以代码点的形式编写，如下所示：
echo "the \u{1F632} face";
echo "the \u{1F609} face";
echo "the \u{1F60F} face";
在较早版本的 PHP 中，前面语句的输出将如下所示：
the \u{1F632} face
the \u{1F609} face
the \u{1F60F} face
显然，这并没有解析代码点，因为它会直接输出它们。
PHP 7 引入了 Unicode 代码点转义序列语法到字符串文字中，使以前的语句产生以下输出：
the 😉 face
the 😉 face
the 😉 face
```php
## 断言
断言是一种调试功能，用于检查给定的断言，并在其结果为`false`时采取适当的操作。它们一直是 PHP 的一部分，自 PHP 4 以来就一直存在。
断言与错误处理的不同之处在于，断言涵盖了不可能的情况，而错误是可能的并且需要被处理。
应避免将断言用作通用错误处理机制。断言不允许从错误中恢复。断言失败通常会停止程序的执行。
使用现代调试工具如 Xdebug，不多的开发人员会使用断言进行调试。
断言可以通过`assert_options`函数或`assert.active INI`设置轻松启用和禁用。
要使用断言，我们可以传入一个表达式或字符串，如下面的函数签名所示：
// PHP 5 bool assert ( mixed description ] )
// PHP 7 bool assert ( mixed exception ] )
这两个签名在第二个参数上有所不同。PHP 7 可以接受字符串`$description`或`$exception`。
如果表达式的结果或字符串的求值结果为`false`，则会发出警告。如果第二个参数传递为`$exception`，则会抛出异常而不是失败。
关于`php.ini`配置选项，`assert`函数已扩展以允许所谓的*零成本断言*：
zend.assertions = 1 // Enable zend.assertions = 0 // Disable zend.assertions = -1 // Zero-cost
使用零成本设置，断言对性能和执行没有任何影响，因为它们不会被编译。
最后，**INI**设置中添加了`Boolean assert.exception`选项。将其设置为`true`，会导致失败的断言引发`AssertionError`异常。
## 对`list()`构造的更改
在 PHP 5 中，`list()`从最右边的参数开始分配值。在 PHP 7 中，`list()`从最左边的参数开始。基本上，现在的值按照它们被定义的顺序分配给变量。
然而，这只影响了`list()`与`array []`操作符一起使用的情况，如下面的代码块中所讨论的：
