• Expression（表达式）
    • Variable（变量）
      • Variable And Constants Declaration（变量与常量声明）
      • Variable Hoisting（变量提升）
    • Assignment（变量赋值）
      • Pass-by-Value & Pass-by-Reference（传值与传引用）
      • Continuous Assignment（连续赋值）
      • Destructuring Assignment（解构赋值）
      • Copy Composite DataTypes（复合类型拷贝）
  • Operator（运算符）
    1. - Basic（基本运算符）
    2. - Bit Operator（位运算符）
    3. - Operator Overloading（运算符重载）
  • Scope & Closure（作用域与闭包）
  • Lazy Evaluation（惰性求值）

    表达式（Expression）

变量（Variable）

变量与常量声明（Variable And Constants Declaration）

变量声明（Variable Declaration）

1.基础变量

PHP 中的变量用一个美元符号后面跟变量名来表示。变量名是区分大小写的。变量名与 PHP 中其它的标签一样遵循相同的规则。一个有效的变量名由字母或者下划线开头，后面跟上任意数量的字母，数字，或者下划线。按照正常的正则表达式，它将被表述为：[a-zA-Z\x7f-\xff][a-zA-Z0-9\x7f-\xff]* 。

Example

  1. <?php
  3. $username = "Leon Kennedy";         // 通过
  4. $_username = "Leon Kennedy";        // 通过
  5. $username1 = "a1";                  // 通过
  6. $user.name = "Leon Kennedy";        // 报错
  7. $用户名称 = "初七";                   // 通过
  8. $UserName = "Leon Kennedy";         // 通过
  9. $userName = "Leon";                 // 通过
  10. $user_name = "Cissy";               // 通过
  11. $1 = 100;                           // 报错
  12. $_100 = 100;                        // 通过

2.**预定义变量

PHP 提供了大量的预定义变量。由于许多变量依赖于运行的服务器的版本和设置，及其它因素，所以并没有详细的说明文档。一些预定义变量在 PHP 以命令行形式运行时并不生效。PHP 中的许多预定义变量都是“超全局”，这意味它们在一个脚本的全部作用域中都可用。

  • $GLOBALS：获取全局变量
  • $_SERVER：获取服务器相关信息
  • $_GET：获取 HTTP GET 请求数据
  • $_POST：获取 HTTP POST 请求数据
  • $_FILES：获取 HTTP 上传文件请求数据
  • $_COOKIE：获取 COOKIE 数据
  • $_SESSION：获取 SESSION 数据
  • $_REQUEST：获取 HTTP 请求数据
  • $_ENV：获取环境变量
  • $php_errormsg：前一个错误信息
  • $HTTP_RAW_POST_DATA：原生POST数据
  • $http_response_header：HTTP 响应头
  • $argc：传递给脚本的参数数目
  • $argv：传递给脚本的参数数组

Example

  1. <?php
  3. foreach($_SERVER as $key => $value){
  4.     echo "{$key} => {$value}\n";
  5. }
  1. [           ]()      [           ]()  <br />**3.变量范围**<br />**<br />变量的范围即它定义的上下文背景（也就是它的生效范围）。大部分的 PHP 变量只有一个单独的范围。可以使用 global 关键字声明全局变量。
  1. <?php
  3. $a = 1;
  4. $b = 2;
  6. function sum()
  7. {
  8.     global $a, $b;
  9.     $b = $a + $b;
  10. }
  12. sum();
  13. echo $b;
  14. ?>
  16. <?php
  18. function sum_again()
  19. {
  20.     // $_GLOBALS 是一个关联数组，每一个变量为一个元素，键名对应变量名，值对应变量的内容
  21.     $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
  22. }
  24. sum();
  25. echo $b;
  27. ?>

也可以使用 static 关键字在声明静态变量。

  1. <?php
  3. function test(){
  4.   static $a = 0;
  5.   echo $a;
  6.   $a++;
  7. }
  9. test();
  10. test();
  11. test();
  12. test();     // 输出结果为：0123

4.可变变量
**
有时候使用可变变量名是很方便的。就是说，一个变量的变量名可以动态的设置和使用。

  1. <?php
  3. $Bar = "a";
  4. $Foo = "Bar";
  5. $World = "Foo";
  6. $Hello = "World";
  7. $a = "Hello";
  9. echo $a."\n";         // Hello
  10. echo $$a."\n";        // World
  11. echo $$$a."\n";       // Foo
  12. echo $$$$a."\n";      // Bar
  13. echo $$$$$a."\n";     // a
  14. echo $$$$$$a."\n";    // Hello
  15. echo $$$$$$$a."\n";   // World

5.来自 PHP 之外的变量

  • HTML 表单（GET 和 POST）
    • 通过预定义变量 $_GET 和 $_POST 获取。
    • 变量名中的点和空格被转换成下划线。例如 <input name="a.b" /> 变成了 $_REQUEST["a_b"]。
  • HTTP 表单（Form）提交数据的方式
    1. - `enctype="application/x-www-form-urlencoded"` （默认值）
    2. - `enctype="multipart/form-data"` 
    3. - 只有当 POST 方法配合 `enctype=multipart/form-data` 时才能正确传输文件。
    4. - 使用 PUT、PATCH 方法时，需要使用 `enctype="x-www-form-urlencoded"` 。
  • HTTP Cookies
    • 如果要将多个值赋给一个 cookie 变量，必须将其赋成数组。

常量声明（Constants Declaration）

1.语法
**
可以用 define() 函数来定义常量，在 PHP 5.3.0 以后，可以使用 const关键字在类定义之外定义常量。一个常量一旦被定义，就不能再改变或者取消定义。

  1. <?php
  3. define("SEBASTIAN", "Sebastian");
  4. const KENNEDY = "Kennedy";
  5. echo SEBASTIAN.' '.KENNEDY."\n";
  7. const ARR = ['sebastian', 'kennedy'];
  8. var_dump(ARR);

2.预定义常量（魔术常量）
**

  • __LINE__：文件中的当前行号。
  • __FILE__：文件的完整路径和文件名。
  • __DIR__：文件所在的目录。
  • __FUNCTION__：返回函数被定义时的名字（区分大小写）。
  • __CLASS__：返回该类被定义时的名字（区分大小写）。
  • __TRAIT__：返回 trait 被定义时的名字（区分大小写）。
  • __METHOD__：返回该方法被定义时的名字（区分大小写）。
  • __NAMESPACE__：当前命名空间的名称（区分大小写）。
  1. <?php
  3. namespace SebastianKennedy\Code;
  5. $line = __LINE__."\n";
  6. $filePath = __FILE__."\n";
  7. $dirPath = __DIR__."\n";
  9. function testFunc(){
  10.     return __FUNCTION__."\n";
  11. }
  13. echo $line;
  14. echo $filePath;
  15. echo $dirPath;
  16. echo testFunc();
  18. trait TestTrait
  19. {
  20.     public function testTrait(){
  21.         return __TRAIT__."\n";
  22.     }
  23. }
  25. class TestClass
  26. {
  27.     use TestTrait;
  29.     public function __construct(){
  30.         return __CLASS__."\n";
  31.     }
  33.     public function testMethod(){
  34.         return __METHOD__."\n";
  35.     }
  37.     public function testNameSpace(){
  38.         return __NAMESPACE__."\n";
  39.     }
  40. }
  42. $class = new TestClass;
  43. echo $class->testMethod();
  44. echo $class->testTrait();
  45. echo $class->testNameSpace();

变量提升（Variable Hoisting）

因为 PHP 区别全局作用域、函数作用域和块级作用域，PHP 不存在变量提升这个特性。

  1. <?php
  3. $param = 10;
  5. function test($param){
  6.     echo $param;
  7.     $param = "Luis Edware";
  8. }
  10. test($param);

变量赋值（Assignment）

传值与传引用（Pass by Value & Pass by Reference）

PHP 支持四种标量值（标量值不能拆分为更小的单元）：整型值（integer）、浮点数值（float）、字符串值（string）和布尔值（boolean）。PHP 也支持两种复合类型：数组（Array）和对象（Object）。PHP 还支持两种特殊类型：资源（resource）和空（null）。

PHP 变量默认总是传值赋值。那也就是说，当将一个表达式的值赋予一个变量时，整个原始表达式的值被赋值到目标变量。这意味着，例如，当一个变量的值赋予另外一个变量时，改变其中一个变量的值，将不会影响到另外一个变量。PHP 也提供了另外一种方式给变量赋值：引用赋值。这意味着新的变量简单的引用了原始变量。改动新的变量将影响到原始变量，反之亦然。PHP 的引用就是同一个变量的别名。

  1. <?php
  3. $foo = 'Bob';
  4. $bar = &$foo;
  5. $bar = "My name is $bar";
  6. echo $bar,$foo;
  8. // 非法的引用赋值；引用没有名字的表达式
  9. $bar = &(24 * 7);
  11. // 非法的引用赋值；只有已经命名的变量才可以引用赋值
  12. function test()
  13. {
  14.     return 25;
  15. }
  16. $bar = &test();

PHP 引用相关文章：

连续赋值（Continuous Assignment）

  1. <?php
  3. $a = $b = $c = 200;
  4. var_dump($a);
  5. var_dump($b);
  6. var_dump($c);
  8. $foo = $bar = $baz = "Sebastian Kennedy\n";
  9. echo $foo, $bar, $baz;
  11. $arr1 = $arr2 = $arr3 = ['github','coding','gitlab'];
  12. var_dump($arr1);
  13. var_dump($arr2);
  14. var_dump($arr3);
  16. // 可以通过 () 来改变运算符的优先级
  17. $a = ($b = 4) + 5;
  18. echo $a."\n";
  20. // 组合赋值
  21. $a .= $b .= "foo";
  22. echo $a."\n";
  24. // 不用第三个变量，交换两个变量的值
  25. $a = 666;
  26. $b = 233;
  27. $a ^= $b ^= $a ^= $b;
  28. echo $a." - ",$b."\n";
  30. // 不用第三个变量，交换两个变量的值
  31. $a = 222;
  32. $b = 333;
  33. list($a, $b) = [$b, $a];
  34. echo $a." - ",$b."\n";

解构赋值（Destructuring Assignment）

  1. <?php
  3. $string = "七月十五九月初七,十二月初一九月二十九";
  4. $arr = [
  5.     ["id" => 1, "name" => 'Sebastian'],
  6.     ["id" => 2, "name" => 'Kennedy'],
  7. ];
  9. // list() style
  10. list($foo, $bar) = explode(',', $string);
  11. echo $foo." - ".$bar."\n";
  13. list("id" => $id1, "name" => $name1) = $arr[0];
  14. echo $id1." => ". $name1."\n";
  16. // [] style
  17. [$a, $b] = explode(',', $string);
  18. echo $a." - ". $b."\n";
  20. ["id" => $id2, "name" => $name2] = $arr[1];
  21. echo $id2." => ", $name2."\n";

复合类型拷贝（Copy Composite DataTypes）

对象复制可以通过 clone 关键字来完成，对象中的 __clone()方法不能被直接调用。当对象被复制后，PHP 会对对象的所有属性执行一个浅复制（shallow copy）。所有的引用属性 仍然会是一个指向原来的变量的引用。

注意: 引用和拷贝的区别是：拷贝是将原来的变量内容复制下来，拷贝后的变量与原来的变量使用各自的内存，互不干扰。 引用相当于是变量的别名，其实就是用不同的名字访问同一个变量内容。当改变其中一个变量的值时，另一个也跟着发生变化。

对于 PHP 对象来说，简单的赋值并不能实现克隆，因为对象是通过伪引用传递的。

  1. <?php
  3. class Example{
  5.     private $a = 1;
  7.     public function plus() {
  8.             $this->a++;
  9.     }
  11.     public function foo() {
  12.                 echo "a={$this->a}\n";
  13.     }
  14. }
  16. $obj = new Example;
  17. $obj->foo();    // 输出 a=1
  19. $obj2 = $obj;
  20. $obj2->plus();
  21. $obj2->foo();   // 输出 a=2
  23. $obj->foo();    // 输出 a=2

PHP 提供了 clone 关键字来实现对象的克隆，如下：

  1. <?php
  3. class Example{
  5.     private $a = 1;
  7.     public function plus() {
  8.             $this->a ++;
  9.     }
  11.     public function foo() {
  12.                 echo "a={$this->a}\n";
  13.     }
  14. }
  16. $obj = new Example();
  17. $obj2 = clone $obj;
  19. $obj->foo();    // 输出 a=1
  21. $obj2->plus();
  22. $obj2->foo();   // 输出 a=2
  24. $obj->foo();    // 输出 a=1

当复制完成时, 如果定义了 __clone() 方法， 则新创建的对象中的 __clone() 方法会被调用， 可用于修改属性的值，如下：

  1. <?php
  3. class Example{
  5.     private $a = 1;
  7.     private $instance_no;       // instance 编号
  9.     static public $all = 0;     // instance 总数
  11.     public function foo() {
  12.         echo "a={$this->a}\n";
  13.     }
  15.     public function bar() {
  16.         echo "instance={$this->instance_no}\n";
  17.     }
  19.     public function __construct() {
  20.         // 实例号＋1
  21.         $this->instance_no = ++self::$all;
  22.     }
  24.     public function __clone() {
  25.         // 实例号＋1
  26.         $this->instance_no = ++self::$all;
  27.     }
  28. }
  30. $obj = new Example();
  31. $obj->foo();
  32. $obj->bar();
  33. echo $obj::$all."\n";
  35. $obj2 = clone $obj;
  36. $obj2->foo();
  37. $obj2->bar();
  38. echo $obj2::$all."\n";

在 PHP 中，克隆会把对象的所有属性进行克隆，但是如果一个对象中包含引用属性，那么克隆之后，在新生成的对象中这个属性仍然是指向于原来变量的引用，这个成为浅克隆，代码如下：

  1. <?php
  3. class Example{
  4.     private $a = 1;
  6.     public $obj;
  8.     public function plus() {
  9.         $this->a++;
  10.     }
  12.     public function foo() {
  13.         echo "a={$this->a}\n";
  14.     }
  15. }
  17. class Example2{
  18.     public $b = 1;
  20.     public function plus() {
  21.         $this->b ++;
  22.     }
  24.     public function foo() {
  25.         echo "b={$this->b}\n";
  26.     }
  27. }
  29. $obj = new Example;
  30. $obj->obj = new Example2;
  31. $obj2 = clone $obj;
  33. // 修改对象的普通属性
  34. $obj->plus();
  35. $obj->foo();    // 输出 a=2
  36. $obj2->foo();   // 输出 a=1
  38. // 修改对象的引用属性
  39. $obj->obj->plus();
  40. $obj->obj->foo();  // 输出 b=2
  41. $obj2->obj->foo(); // 输出 b=2

PHP 如果需要实现深克隆,需要自己实现对引用属性的完全复制，代码如下：

  1. <?php
  3. class Example{
  5.     private $a = 1;
  7.     public $obj;
  9.     public function plus() {
  10.         $this->a ++;
  11.     }
  13.     public function foo() {
  14.         echo "a={$this->a}\n";
  15.     }
  17.     public function __clone(){
  18.         // 当存在对象数组的时候，可以使用以下代码实现深克隆
  19.         foreach($this as $key => $value){
  20.             if (is_object($value) || (is_array($value))) {
  21.                 $this->{$key} = unserialize(serialize($value));
  22.             }
  23.         }
  24.     }
  25. }
  27. class Example2{
  29.     public $b = 1;
  31.     public function plus() {
  32.         $this->b ++;
  33.     }
  35.     public function foo() {
  36.         echo "b={$this->b}\n";
  37.     }
  38. }
  40. $obj = new Example;
  41. $obj->obj = new Example2;
  42. $obj2 = clone $obj;
  44. // 修改对象的普通属性
  45. $obj->plus();
  46. $obj->foo();    // 输出 a=2
  47. $obj2->foo();   // 输出 a=1
  49. // 修改对象的引用属性
  50. $obj->obj->plus();
  51. $obj->obj->foo();  // 输出 b=2
  52. $obj2->obj->foo(); // 输出 b=1

运算符（Operator）

运算符是可以通过给出的一或多个值（用编程行话来说，表达式）来产生另一个值（因而整个结构成为一个表达式）的东西。运算符的种类有：

  • 基本运算符（Basic Operators）
    • 算术运算符（Assignment Operator）
    • 比较运算符（Comparison Operator）
    • 错误控制运算符（Error Control Operator）
    • 执行运算符（Execution Operator）
    • 递增/递减运算符（Incrementing / Decrementing Operator）
    • 逻辑运算符（Logical Operator）
    • 字符串运算符（String Operator）
    • 数组运算符（Array operator）
    • 类型运算符（Type Operator）
  • 位运算符（Bit Operator）
  • 运算符重载（Operator Overloading）

基本运算符（Basic Operators）

算术运算符（Assignment Operator）

例子 名称 结果
-$a 取反 $a 的负值。
$a + $b 加法 $a 和 $b 的和。
$a - $b 减法 $a 和 $b 的差。
$a * $b 乘法 $a 和 $b 的积。
$a / $b 除法 $a 除以 $b 的商。
$a % $b 取模 $a 除以 $b 的余数。
$a ** $b 幂 $a 的 $b 次平方

比较运算符（Comparison Operator）

例子 名称 结果
$a == $b 等于 TRUE，如果类型转换后 $a 等于 $b。
$a === $b 全等 TRUE，如果 $a 等于 $b，并且它们的类型也相同。
$a != $b 不等 TRUE，如果类型转换后 $a 不等于 $b。
$a <> $b 不等 TRUE，如果类型转换后 $a 不等于 $b。
$a !== $b 不全等 TRUE，如果 $a 不等于 $b，或者它们的类型不同。
$a < $b 小与 TRUE，如果 $a 严格小于 $b。
$a > $b 大于 TRUE，如果 $a 严格大于 $b。
$a <= $b 小于等于 TRUE，如果 $a 小于或者等于 $b。
$a >= $b 大于等于 TRUE，如果 $a 大于或者等于 $b。
$a <=> $b 结合比较运算符 当 $a 小于、等于、大于 $b 时 分别返回一个小于、等于、大于 0 的 integer 值。 PHP 7 开始提供.
$a ?? $b ?? $c NULL 合并操作符 从左往右第一个存在且不为 NULL 的操作数。如果都没有定义且不为 NULL，则返回 NULL。PHP 7 开始提供。

错误控制运算符（Error Control Operator）

PHP 支持一个错误控制运算符：@ 。当将其放置在一个 PHP 表达式之前，该表达式可能产生的任何错误信息都被忽略掉。

执行运算符（Execution Operator）

PHP 支持一个执行运算符：反引号（`）。注意这不是单引号！PHP 将尝试将反引号中的内容作为 shell 命令来执行，并将其输出信息返回（即，可以赋给一个变量而不是简单地丢弃到标准输出）。使用反引号运算符“”的效果与函数 shell_exec() 相同。

  1. <?php
  3. $output = `ls -al`;
  4. echo "<pre>$output</pre>";

递增/递减运算符（Incrementing / Decrementing Operator）

例子 名称 结果
++$a 前加 $a 的值加一，然后返回 $a。
$a++ 后加 返回 $a，然后将 $a 的值加一。
–$a 前减 $a 的值减一， 然后返回 $a。
$a– 后减 返回 $a，然后将 $a 的值减一。

一个简单的示例脚本

  1. <?php
  2. echo "<h3>Postincrement</h3>";
  3. $a = 5;
  4. echo "Should be 5: " . $a++ . "\n";
  5. echo "Should be 6: " . $a . "\n";
  6. echo "<h3>Preincrement</h3>";
  7. $a = 5;
  8. echo "Should be 6: " . ++$a . "\n";
  9. echo "Should be 6: " . $a . "\n";
  10. echo "<h3>Postdecrement</h3>";
  11. $a = 5;
  12. echo "Should be 5: " . $a-- . "\n";
  13. echo "Should be 4: " . $a . "\n";
  14. echo "<h3>Predecrement</h3>";
  15. $a = 5;
  16. echo "Should be 4: " . --$a . "\n";
  17. echo "Should be 4: " . $a . "\n";

逻辑运算符（Logical Operator）

例子 名称 结果
$a and $b And（逻辑与） TRUE，如果 $a 和 $b 都为 TRUE。
$a or $b Or（逻辑或） TRUE，如果 $a 或 $b 任一为 TRUE。
$a xor $b Xor（逻辑异或） TRUE，如果 $a 或 $b 任一为 TRUE，但不同时是。
! $a Not（逻辑非） TRUE，如果 $a 不为 TRUE。
$a && $b And（逻辑与） TRUE，如果 $a 和 $b 都为 TRUE。
$a || $b Or（逻辑或） TRUE，如果 $a 或 $b 任一为 TRUE。

字符串运算符（String Operator）

有两个字符串（string）运算符。第一个是连接运算符（“.”），它返回其左右参数连接后的字符串。
第二个是连接赋值运算符（“.=”），它将右边参数附加到左边的参数之后。代码如下：

  1. <?php
  3. $a = "Hello ";
  4. $b = $a . "World!"; // now $b contains "Hello World!"
  6. $a = "Hello ";
  7. $a .= "World!";     // now $a contains "Hello World!"

数组运算符（Array Operator）

例子 名称 结果
$a + $b 联合 $a 和 $b 的联合。
$a == $b 相等 如果 $a 和 $b 具有相同的键／值对则为 TRUE。
$a === $b 全等 如果 $a 和 $b 具有相同的键／值对并且顺序和类型都相同则为 TRUE。
$a != $b 不等 如果 $a 不等于 $b 则为 TRUE。
$a <> $b 不等 如果 $a 不等于 $b 则为 TRUE。
$a !== $b 不全等 如果 $a 不全等于 $b 则为 TRUE。

对象类型运算符（Object Type Operator）

instanceof 用于确定一个 PHP 变量是否属于某一类 class 的实例，常见的场景是异常错误捕获

  1. <?php
  3. class ParentClass
  4. {
  5. }
  7. class MyClass extends ParentClass
  8. {
  9. }
  11. $a = new MyClass;
  12. var_dump($a instanceof MyClass);
  13. var_dump($a instanceof ParentClass);

位运算符

例子 名称 结果
$a & $b And（按位与） 将把 $a 和 $b 中都为 1 的位设为 1。
$a $b Or（按位或） 将把 $a 和 $b 中任何一个为 1 的位设为 1。
$a ^ $b Xor（按位异或） 将把 $a 和 $b 中一个为 1 另一个为 0 的位设为 1。
~ $a Not（按位取反） 将 $a 中为 0 的位设为 1，反之亦然。
$a << $b Shift left（左移） 将 $a 中的位向左移动 $b 次（每一次移动都表示“乘以 2”）。
$a >> $b Shift right（右移） 将 $a 中的位向右移动 $b 次（每一次移动都表示“除以 2”）。

运算符重载（Operator Overloading）- [Web 领域几乎没有使用场景]

PHP 5.6新特性之一：内部操作符重载

在计算机程序设计中，运算符重载是多态的一种。这里，运算符被当作多态函数，他们的行为随着其参数类型的不同而不同。简而言之，运算符重载使程序员能够根据运算子类型的不同来决定运算符功能的不同。PHP 支持运算符重载。PHP 5.6 之后，GMP 支持运算符重载，并且造型成数值类型，这使得使用 GMP 的代码更加直观。

  1. <?php
  3. $a = gmp_init(42);
  4. $b = gmp_init(17);
  6. // 意思就是 $a + $b 的 + 的作用等同于 gmp_add() 函数，让代码更加直观。
  7. if (version_compare(PHP_VERSION, '5.6', '<')) {
  8.     echo gmp_intval(gmp_add($a, $b)), PHP_EOL;
  9.     echo gmp_intval(gmp_add($a, 17)), PHP_EOL;
  10.     echo gmp_intval(gmp_add(42, $b)), PHP_EOL;
  11. } else {
  12.     echo $a + $b, PHP_EOL;
  13.     echo $a + 17, PHP_EOL;
  14.     echo 42 + $b, PHP_EOL;
  15. }

运算符优先级（Operator Precedence）

  1. 递增/递减 > ! > 算术运算符 > 大小比较 > (不)相等比较 > 引用 >
  2. 位运算符 ^ > 位运算符 | > 逻辑与 > 逻辑或 > 三目 > 赋值 > and > xor > or
  • 算术运算符（Assignment Operator）
  • 比较运算符（Comparison Operator）
  • 错误控制运算符（Error Control Operator）
  • 执行运算符（Execution Operator）
  • 递增/递减运算符（Incrementing / Decrementing Operator）
  • 逻辑运算符（Logical Operator）
  • 字符串运算符（String Operator）
  • 数组运算符（Array operator）
  • 类型运算符（Type Operator）

匿名函数与闭包（Anonymous functions & Closure）

闭包和匿名函数在 PHP 5.3 中被引入。闭包是指在创建时封装函数周围状态的函数，即使闭包所在的环境不存在了，闭包封装的状态依然存在。匿名函数其实就是没有名称的函数，匿名函数可以赋值给变量，还能像其他任何 PHP 对象那样传递。最经常用作回调函数参数的值。匿名函数和闭包目前是通过 Closure 类来实现的。

Example:

  1. <?php
  3. $closure = function($name){
  4.     return sprintf('hello %s', $name);
  5. };
  7. echo $closure("Sebastian Kennedy");

之所以能够调用 $closure 变量，是因为这个变量的值是一个闭包对象，而且闭包对象实现了 __invoke() 魔术方法。只要变量名后有 ()，PHP 就会查找并调用 __invoke() 方法：

  1. <?php
  3. class testClosureClass
  4. {
  5.     public function __invoke()
  6.     {
  7.         echo "Hello World";
  8.     }
  9. }
  11. $closure = new testClosureClass;
  12. $closure();     // 输出 Hello World

PHP 闭包一般当做函数或方法的回调来使用，如下：

  1. <?php
  3. $numbersPlusOne = array_map(function ($number) {
  4.     return $number + 1;
  5. }, [1, 2, 3]);
  7. var_export($numbersPlusOne);

PHP 闭包不会像 JavaScript 闭包那样自动封装应用的状态。在 PHP 中，必须手动调用闭包对象的 bindTo() 方法或者使用 use 关键字，把状态附加到 PHP 闭包上。以下是使用 use 关键字附加闭包的状态：

  1. <?php
  3. function enclosePerson($name)
  4. {
  5.     return function ($doCommand) use ($name) {
  6.         return sprintf('%s, %s', $name, $doCommand);
  7.     };
  8. }
  10. //把字符串 "Clay" 封装在闭包中
  11. $clay = enclosePerson('Clay');
  13. //传入参数，调用闭包
  14. echo $clay('get me sweat tea!'); // Clay, get me sweat tea!

我们可以通过 bindTo() 方法的第一个参数把 Closure 对象的内部状态绑定到其他对象上。可以通过 bindTo()方法的第二个参数指定绑定闭包的那个对象所属的 PHP 类。以下是使用 bindTo() 方法附加闭包的状态：

  1. <?php
  3. class App
  4. {
  5.   protected $routes = [];
  6.   protected $responseStatus = '200 OK';
  7.   protected $responseContentType = 'text/html';
  8.   protected $responseBody = 'Hello world';
  10.   public function addRoute($routePath, $routeCallback)
  11.   {
  12.     $this->routes[$routePath] = $routeCallback->bindTo($this, __CLASS__);
  13.   }
  15.   public function dispatch($currentPath)
  16.   {
  17.     foreach($this->routes as $routePath => $callback) {
  18.       if ($routePath === $currentPath) {
  19.          $callback();
  20.       }
  21.     }
  22.     header('HTTP/1.1' . $this->responseStatus);
  23.     header('Content-type: ' . $this->responseContentType);
  24.     header('Content-length: ' . mb_strlen($this->responseBody));
  25.     echo $this->responseBody;
  26.   }
  27. }
  29. $app = new App();
  31. $app->addRoute('/users/1', function () {
  32.   $this->responseContentType = 'application/json;charset=utf8';
  33.   $this->responseBody = '{"name" : "Luis Edware", "phone" : "14089950522"}';
  34. });
  36. $app->dispatch('/users/1');

惰性求值（Lazy Evaluation）

  1. <?php
  3. class Shooting
  4. {
  5.     public function __construct(){
  6.         echo "Biu! Biu! Biu! Da! Da! Da!\n";
  7.     }
  8. }
  10. class Scar
  11. {
  12.     private $closure;
  13.     private $instance;
  15.     public function __construct(Closure $closure){
  16.         $this->closure = $closure;
  17.         $this->instance = $closure->bindTo($this, __CLASS__);
  18.     }
  20.     public function shoot(){
  21.         $closure = $this->closure;
  22.         return $closure();
  23.     }
  25.     public function shootAgain(){
  26.         $closure = $this->instance;
  27.         return  $closure();
  28.     }
  29. }
  31. $scar = new Scar(function(){
  32.     return new Shooting;
  33. });
  35. // 不触发射方法就不会 Biu Biu Biu!
  36. $scar->shoot();
  37. $scar->shootAgain();
  • 流程控制与异常处理（ControlFlow）
    • 分支选择（Branch）
      • if
      • switch
    • 循环（Loop）
      • for
      • white
      • break / continue
    • 错误处理（ErrorHanding）
      • 异常抛出（Throw）
      • 异常捕获（Try Catch Finally）

流程控制与异常处理（ControlFlow）

分支选择（Branch）

PHP 提供了一些流程控制的替代语法，包括 if，while，for，foreach 和 switch。 替代语法的基本形式是把左花括号 { 换成冒号 :，把右花括号 } 分别换成 endif;，endwhile;，endfor;，endforeach; 以及 endswitch;。

if

if 结构是很多语言包括 PHP 在内最重要的特性之一，它允许按照条件执行代码片段。PHP 的 if 结构和 C 语言相似：

  1. <?php
  3. $a = 1;
  4. $b = 2;
  6. if ($a > $b) {
  7.     echo "a is bigger than b\n";
  8. }
  10. if ($a > $b) {
  11.     echo "a is bigger than b\n";
  12.     $b = $a;
  13. }
  15. if ($a > $b) {
  16.     echo "a is greater than b\n";
  17. } else {
  18.     echo "a is NOT greater than b\n";
  19. }
  21. if ($a > $b) {
  22.     echo "a is bigger than b\n";
  23. } elseif ($a == $b) {
  24.     echo "a is equal to b\n";
  25. } else {
  26.     echo "a is smaller than b\n";
  27. }
  29. if ($a > $b):
  30.     echo $a." is greater than ".$b."\n";
  31. elseif ($a == $b):
  32.     echo $a." equals ".$b."\n";
  33. else:
  34.     echo $a." is neither greater than or equal to ".$b."\n";
  35. endif;

和 HTML / JavaScript / CSS 混合使用:

  1. <?php if (condition): ?>
  2.     html code to run if condition is true
  3. <?php else: ?>
  4.     html code to run if condition is false
  5. <?php endif ?>

Switch

switch 语句类似于具有同一个表达式的一系列 if 语句。 很多场合下需要把同一个变量（或表达式）与很多不同的值比较，并根据它等于哪个值来执行不同的代码。switch 是松散比较。

  1. <?php
  3. // 整型的 switch 结构
  4. $integer = array_rand(range(0, 2));
  5. switch ($integer) {
  6.     case 0:
  7.         echo "integer equals 0\n";
  8.         break;
  9.     case 1:
  10.         echo "integer equals 1\n";
  11.         break;
  12.     case 2:
  13.         echo "integer equals 2\n";
  14.         break;
  15. }
  17. // 字符串型的 switch 结构
  18. $string = array_rand(['foo' => 0, 'bar' => 1, 'baz' => 2]);
  19. switch ($string) {
  20.     case "foo":
  21.         echo "string is foo\n";
  22.         break;
  23.     case "bar":
  24.         echo "string is bar\n";
  25.         break;
  26.     case "baz":
  27.         echo "string is baz\n";
  28.         break;
  29. }

这里如果 $i 等于 0，PHP 将执行所有的 echo 语句！如果 $i 等于 1，PHP 将执行后面两条 echo 语句。只有当 $i 等于 2 时，才会得到“预期”的结果——只显示“i equals 2”。

循环（Loop）

for

for 循环是 PHP 中最复杂的循环结构。for 循环的语法如下：

  1. for (expr1; expr2; expr3)
  2.     statement
  4. expr1 在循环开始前无条件求值（并执行）一次。
  5. expr2 在每次循环开始前求值。如果值为 true，则继续循环，执行嵌套的循环语句。如果值为 false，则终止循环。
  6. expr3 在每次循环之后被求值（并执行）。

for 示例代码如下：

  1. <?php
  3. // Example 1
  4. for ($i = 1; $i <= 10; $i++) {
  5.     echo $i."\n";
  6. }
  8. // Example 2
  9. for ($i = 1; ; $i++) {
  10.     if ($i > 10) {
  11.         break;
  12.     }
  13.     echo $i."\n";
  14. }
  16. // Example 3
  17. for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i."\n", $i++);
  19. // Example 4
  20. $people = [
  21.     ['name' => 'Kalle', 'salt' => 856412],
  22.     ['name' => 'Pierre', 'salt' => 215863],
  23. ];
  24. $count = count($people);
  25. for ($i = 0, $size = $count; $i < $size; ++$i) {
  26.     $people[$i]['salt'] = rand(000000, 999999);
  27. }
  28. var_export($people);

foreach

foreach 语法结构提供了遍历数组的简单方式。foreach 仅能够应用于数组和对象，
如果尝试应用于其他数据类型的变量，或者未初始化的变量将发出错误信息。

foreach 的示例代码

  1. <?php
  3. // Example 1 while 和 foreach 实现相同功能的代码
  4. $arr = ["foo", "bar", "baz"];
  6. // 输出数组中的当前元素和下一个元素的值，然后把数组的内部指针重置到数组中的第一个元素
  7. reset($arr);
  8. while (list(, $value) = each($arr)) {
  9.     echo "Value: $value<br>\n";
  10. }
  11. foreach ($arr as $value) {
  12.     echo "Value: $value<br />\n";
  13. }
  15. // Example 2 while 和 foreach 实现相同功能的代码
  16. $arr = ["one", "two", "three"];
  17. reset($arr);
  18. while (list($key, $value) = each($arr)) {
  19.     echo "Key: $key; Value: $value<br />\n";
  20. }
  21. foreach ($arr as $key => $value) {
  22.     echo "Key: $key; Value: $value<br />\n";
  23. }
  25. // Example 3 多维数组遍历
  26. $a = [];
  27. $a[0][0] = "a";
  28. $a[0][1] = "b";
  29. $a[1][0] = "y";
  30. $a[1][1] = "z";
  31. foreach ($a as $v1) {
  32.     foreach ($v1 as $v2) {
  33.         echo "$v2\n";
  34.     }
  35. }
  37. // Example 4 用 list() 给嵌套的数组解包 1
  38. $array = [
  39.     [1, 2],
  40.     [3, 4],
  41. ];
  42. foreach ($array as list($a, $b)) {
  43.     echo "A: $a; B: $b\n";
  44. }
  46. // Example 5 用 list() 给嵌套的数组解包 2
  47. $array = [
  48.     [
  49.         'username' => "Sebastian",
  50.         'phone' => "13405871293",
  51.         "address" => "广东省深圳市",
  52.     ],
  53.     [
  54.         'username' => "Kennedy",
  55.         'phone' => "15048773920",
  56.         "address" => "广东省深圳市",
  57.     ],
  58. ];
  59. foreach ($array as list('username' => $username, 'phone' => $phone)) {
  60.     echo "$username 's phone is $phone\n";
  61. }
  63. // Example 6 使用 foreach 的替代语法
  64. $names = ['foo', 'bar', 'baz', 'qux'];
  65. foreach ($names as $value):
  66.     echo "$value\n";
  67. endforeach;

while

while 循环是 PHP 中最简单的循环类型。只要 while 表达式的值为 true 就重复执行嵌套中的循环语句。表达式的值在每次开始循环时检查，所以即使这个值在循环语句中改变了，语句也不会停止执行，直到本次循环结束。while 示例代码如下：

  1. <?php
  3. // Example 1
  4. $i = 1;
  5. while ($i <= 10) {
  6.     echo $i++."\n";
  7. }
  9. // Example 2
  10. $i = 1;
  11. while ($i <= 10):
  12.     print $i."\n";
  13.     $i++;
  14. endwhile;

do-while

do-while 循环和 while 循环非常相似，区别在于表达式的值是在每次循环结束时检查而不是开始时。和一般的 while 循环主要的区别是 do-while 的循环语句保证会执行一次。do-while 示例代码如下：

  1. <?php
  3. // Example 1 do-while 只执行一次
  4. $i = 0;
  5. do {
  6.     echo $i."\n";
  7. } while ($i > 0);
  9. // Example 2 do-while 执行 5 次
  10. $i = 0;
  11. do {
  12.     $i++;
  13.     if ($i > 5) {
  14.         break;
  15.     }
  16.     echo "i is not big enough\n";
  17. } while (1);

break / continue

break 结束当前 for，foreach，while，do-while 或者 switch 结构的执行。continue 在 for，foreach，while，do-while 或者 switch 结构用用来跳过本次循环中剩余的代码并在条件求值为真时开始执行下一次循环。break / continue 的示例代码如下：

  1. <?php
  3. $arr = ['one', 'two', 'three', 'four', 'stop', 'five'];
  4. while (list (, $val) = each($arr)) {
  5.     if ($val != 'stop') {
  6.         continue;
  7.     }
  8.     if ($val == 'stop') {
  9.         echo "$val\n";
  10.         break;
  11.     }
  12.     echo "$val<br />\n";
  13. }
  15. // 多层 continue
  16. $i = 0;
  17. while ($i++ < 5) {
  18.     echo "Outer<br />\n";
  19.     while (1) {
  20.         echo "Middle<br />\n";
  21.         while (1) {
  22.             echo "Inner<br />\n";
  23.             continue 3;
  24.         }
  25.         echo "This never gets output.<br />\n";
  26.     }
  27.     echo "Neither does this.<br />\n";
  28. }

goto

goto 操作符可以用来跳转到程序中的另一位置。该目标位置可以用目标名称加上冒号来标记，而跳转指令是 goto 之后接上目标位置的标记。PHP 中的 goto 有一定限制，目标位置只能位于同一个文件和作用域，也就是说无法跳出一个函数或类方法，也无法跳入到另一个函数。也无法跳入到任何循环或者 switch 结构中。goto 示例代码如下：

  1. <?php
  3. // Example 1
  4. goto a;
  5. echo "foo\n";
  6. a:
  7. echo "bar\n";
  9. // Example 2
  10. for ($i = 0, $j = 50; $i < 100; $i++) {
  11.     while ($j--) {
  12.         if ($j === 17) {
  13.             goto end;
  14.         }
  15.     }
  16. }
  17. echo "i = $i\n";
  19. end:
  20. echo 'j hit 17';

错误处理（Error Handing）

错误和异常定义与类型（Error & Exception）

PHP 7 改变了大多数错误的报告方式。不同于传统（PHP 5）的错误报告机制，现在大多数错误被作为 Error 异常抛出。而异常是 Exception 类的对象，在遇到无法修复的状况时抛出。例如，远程 API 无响应，数据库查询失败，或者无法满足前置条件。这些状况被归纳为异常状况。出现问题时，异常常用于主动出击，委托职责，异常还可以用于防守，预测潜在的问题，减轻其影响。

这种 Error 异常可以像 Exception 异常一样被第一个匹配的 try / catch 块所捕获。如果没有匹配的 catch 块，
则调用异常处理函数（事先通过 set_exception_handler() 注册）进行处理。如果尚未注册异常处理函数，则按照传统方式处理：被报告为一个致命错误（Fatal Error）。

Error 类并非继承自 Exception 类，所以不能用 catch (Exception $e) { … } 来捕获 Error。在 PHP 7 以后，可以使用 Throwable 类来捕获 Error，或者你也可以用 catch (Error $e) { … }，或者通过注册异常处理函数（ set_exception_handler()）来捕获 Error。

错误和异常抛出（Throw）

错误和异常实例化时可以赋值给变量，不过一定要把错误或异常抛出。抛出错误或异常后代码会立即停止执行，后续的 PHP 代码都不会运行。抛出错误或异常的方式是使用 throw 关键字，后面要跟着要抛出的 Throwable 实例。

  1. <?php
  3. // Throwable 能够捕获 Exception 和 Error
  4. throw new \Throwable("Something went wrong. Time for lunch!");
  6. // Exception 能够捕获 Exception，不能捕获 Error
  7. throw new \Exception("Something went wrong. Time for dinner!");
  9. // Error 能够捕获 Error，不能捕获 Exception
  10. throw new \Error("Something went wrong. Time for Sleep!");

错误和异常捕获（Try-Catch-Finally）

拦截并处理潜在错误或异常的方式是，把可能抛出异常的代码放在 try / catch 块中，示例代码如下:

  1. <?php
  3. // Example 1
  4. try {
  5.     $pdo = new PDO('mysql://host=wrong_host;dbname=wrong_name');
  6. } catch (PDOException $e) {
  7.     $code = $e->getCode();
  8.     $message = $e->getMessage();
  9.     echo 'Something went wrong.Check back soon, Please';
  10.     exit;
  11. }
  13. // Example 2
  14. try {
  15.     throw new Exception("Not a PDO exception\n");
  16.     $pdo = new PDO('mysql://host=wrong_host;dbname=wrong_name');
  17. } catch (PDOException $e) {
  18.     echo 'Caught PDO exception';
  19. } catch (Throwable $t) {
  20.     // 处理其他异常
  21.     echo $t->getMessage();
  22. }finally {
  23.     // 这里的代码始终都会执行
  24.     echo 'Always do this';
  25. }

错误和异常的部署配置（Deploy & Configuration）

// TODO