[关闭]
@dungan 2018-09-14T07:07:46.000000Z 字数 8609 阅读 103

PHP

PHP 新特性扫盲

最近在看一些开源库的源码，经常发现有一些比如函数类型申明，参数解构之类的新特性，为了帮助理解和记忆，对这些新特性做一些归纳和总结！

php 5.6 新特性

... 运算符

... 这玩意在 JavaScript 叫它剩余参数，我觉得挺形象的，意思就是参数多的数不过来，那就用 ... (省略号)代替呗！

... 定义变长参数函数

以前给函数定义参数的数量是定的

  1. function test($a, $b)
  2. {
  3.    // TODO
  4. }
  6. test(1,2,3,4,5);

像上面这样调用肯定是不行了，但是有了 ... 运算符我们就 可以忽略传入函数的参数数量

  1. function test($a, $b, ...$param)
  2.     {
  3.         sort($param);
  4.         var_dump($param);
  5.     }
  7.     test(1,2,5,4,3);
  8.     /*array(3) {
  9.         [0] =>
  10.       int(3)
  11.       [1] =>
  12.       int(4)
  13.       [2] =>
  14.       int(5)
  15.     }*/

可以看到函数参数中的剩余参数，其类型是数组，我们可以使用数组相关的函数处理它！

... 参数展开

既然能够省略函数参数数量，那也能展开函数参数

  1. function test($a, $b, $c, $d, $e)
  2.     {
  3.         return $a + $b + $c + $d + $e;
  4.     }
  6.     $param = [5, 4, 3];
  7.     test(1,2, ...$param);  // 15

使用 ** 进行幂运算

一个 * 是乘法运算，两个 ** 是幂运算

  1. echo 2*3; //6
  3. echo 2**3; //8
  5. echo 2 ** 3 ** 2;// 512
  6. // 2 ** 3 ** 2 = 2 ** (3**2=9)

use 可以导入常量和函数

格式为 use function 和 use const

  1. namespace Name\Space {
  2.     const FOO = 42;
  3.     function f() { echo __FUNCTION__."\n"; }
  4. }
  6. namespace {
  7.     use  Name\Space\FOO;
  8.     use  Name\Space\f;
  10.     echo FOO."\n";
  11.     f();
  12. }

php://input 输入流是可重用的了

输入流本身是一种资源，资源如果不能复用的话就会很耗内存的！另外注意 enctype="multipart/form-data" 的时候 php://input 是无效的，form-data 意味着你有问价要上传！

__debugInfo()

var_dump 输出对象的时候，会一股脑的输出对象里面『公有的』，『私有的』属性，但现在可以通过__debugInfo 来控制要输出对象的哪些属性和值，比如打印对象 Test 时只想输出它的 $money 属性！

  1. class Test
  2.     {
  3.         public  $money = 100;
  5.         public function __debugInfo()
  6.         {
  7.             return ['money' => $this->money * 100];
  8.         }
  9.     }
  10.     $test = new  Test();
  12.     var_dump($test);
  13.     /*class Test#1 (1) {
  14.       public $money =>
  15.       int(10000)
  16.     }*/

php 7.0 新特性

php7.0 是一个大版本升级，引入了几个重量级的新特性，例如 『类型申明』，『三元运算符合并』，『组合比较符』等等！

类型申明

类型申明是挺有用的，因为你不想战战兢兢的向数据库 int 类型的字段插入数据时还要 intval() 一下！

可用的类型如图

image.png

标量类型声明

标量类型声明有两种模式: 『强制模式』 和 『严格模式』，默认是强制模式！

类型声明允许函数在调用时要求参数为特定类型。 如果给出的值类型不对，那么将会产生一个错误；类型应该加到参数名前！
默认新情况下，PHP 将会强迫错误类型的值转为函数期望的标量类型，正如你看到的，下面的 3.56 被转成成了 int 类型的 3！

  1. function test(int $num)
  2. {
  3.         echo $num;
  4. }
  6. test('3.56');  // 3

可以看到类型申明起作用了，将一个字符类型的数字转换成了它被申明时的

当然你可能觉得应该像正统的oo语言一样，对类型进行严格校验，那么也是可以的！

  1.     declare(strict_types=1);
  3.     function test(int $num)
  4.     {
  5.         echo $num;
  6.     }
  8.     test('3.56');
  9.     // Fatal error: Uncaught TypeError: Argument 1 passed to test()....

当然类型也可以是某个类的实例

  1. class C {}
  3. function f(Array $arr) {
  4.     echo gettype($arr);
  5. }
  7. f([]);   // array
  8. f('');   // Fatal error: Uncaught TypeError ...
返回值类型

 类似于参数类型声明，返回类型声明指明了函数返回值的类型。可用的类型与参数声明中可用的类型相同

  1. function test():int 
  2. {
  3.       return '123';
  4. }
  5. echo  test(); // 123

同样你可以使用严格模式

  1.   declare(strict_types=1);
  3.     function test():int
  4.     {
  5.       return '123';
  6.     }
  8.     echo  test(); // Fatal error: Uncaught TypeError...

返回值也可以是某个类的实例

  1. class C {}
  3. function getC(): C {
  4.     return new C;
  5. }
  7. var_dump(getC());

关于严格模式

  • 要使用严格模式，一个 declare 声明指令必须放在文件的顶部，加了严格模式以后就会对类型申明进行严格判断！
  • 启用严格模式 既影响『标量类型申明』，同时也会影响『返回值类型声明』！
  • 一个没有启用严格模式的文件内调用了一个在启用严格模式的文件中定义的函数，那么将会遵循调用者的偏好（弱类型），而这个值将会被转换，所以在你 require 文件时这点需要注意！

null 合并运算符

?? 运算符本身是对三元运算符的简化

如果变量存在且值不为NULL， 它就会返回自身的值，否则返回它的第二个操作数

  1.     // demo1
  2.     $b = null;
  3.     $a = $b ?? 'a';
  4.     echo  $a;   // a
  6.     // demo2
  7.     $a = $b ?? 'a';
  8.     echo  $a;  // a
  10.     // demo3
  11.     $b = '';
  12.     $a = $b ?? 'a';
  13.     echo  $a;   // 空字符
  15.     // demo4
  16.     $b = '';
  17.     $a = empty($b) ?? 'a';
  18.     echo  $a;   // 1
  20.     // demo5
  21.     $a = isset($b) ?? 'a';
  22.     echo gettype($a);  // boolean

组合比较符

『组合比较符』能够让你避免写 if-else 之类的比较逻辑

组合比较符用于比较两个表达式。当小于、等于或大于b时它分别返回-1、0或1。

  1. // 整数
  2. echo 1 <=> 1; // 0
  3. echo 1 <=> 2; // -1
  4. echo 2 <=> 1; // 1
  6. // 浮点数
  7. echo 1.5 <=> 1.5; // 0
  8. echo 1.5 <=> 2.5; // -1
  9. echo 2.5 <=> 1.5; // 1
  11. // 字符串
  12. echo "a" <=> "a"; // 0
  13. echo "a" <=> "b"; // -1
  14. echo "b" <=> "a"; // 1

通过 define() 定义常量数组

Array 类型的常量之前只能用 const 定义，7.0+ 你可以使用通过『define』定义

  1. define('SUM', [1, 2, 3]);
  3. echo array_sum(SUM); // 6

匿名类

new 一个没有名字的类就是匿名类，7.0 开始支持匿名类， 匿名类很有用，可以创建一次性的简单对象！

  1. // PHP 7 之前的代码
  2. class Logger
  3. {
  4.     public function log($msg)
  5.     {
  6.         echo $msg;
  7.     }
  8. }
  10. $util->setLogger(new Logger());
  12. // 使用了 PHP 7+ 后的代码
  13. $util->setLogger(new class {
  14.     public function log($msg)
  15.     {
  16.         echo $msg;
  17.     }
  18. });

当然匿名类也可以继承其他类、实现接口，使用 trait！

正如匿名函数一样，可以看到匿名类常作为函数的参数出现，就像回调函数函数一样，我们把这种类也可以叫做『回调类』(我自己给取得名字)

匿名函数我们知道可以在函数中被返回形成闭包，匿名类也可以在函数中返回

  1. class Outer
  2. {
  3.     protected $prop1 = 1;
  4.     protected $prop2 = 2;
  6.     public function test()
  7.     {
  8.         return new class() extends Outer
  9.         {
  10.             public $prop3;
  12.             public function __construct()
  13.             {
  14.                 $this->prop3 = $this->prop1 + $this->prop2;
  15.             }
  16.         };
  17.     }
  18. }
  19. echo (new Outer)->test()->prop3;   //3

匿名类也可以赋值给一个变量

  1. class A
  2. {
  3.     private $name;    
  5.     public function __construct($name)
  6.     {
  7.         $this->name = $name;
  8.     }
  10.     public function getName()
  11.     {
  12.         return $this->name;
  13.     }
  14. }
  16. $b = new class('anonymous') extends A
  17. {
  18.     public function getName()
  19.     {
  20.         return parent::getName() . ' class';
  21.     }
  22. };
  24. echo $b->getName(), PHP_EOL;  // anonimous class

Closure::call() 为闭包绑定作用域并执行

7.0 之前为闭包绑定作用域并执行，我们只能通过 IIFE((立即调用的函数表达式)) 这样的淫巧，不过现在有了 『Closure::call()』这一切就变得简单多了！

如果你不理解闭包是什么并且为什么要绑定作用，可以看下我之前写的一遍『 博客』

  1. class Test
  2. {
  3.     private         $num      = 1;
  4. }
  6. $test = new Test();
  8. // PHP 7 之前版本的代码
  9. $closure = function($add)
  10. {
  11.     echo $this->num + $add;
  12. };
  13. (Closure::bind($closure, $test, $test))(1); //2
  16. // PHP 7+ 及更高版本的代码
  17. $closure->call($test, 1); //2

unserialize() 过滤

7.0 为 unserialize 提供了第一个数组参数，它可以对你要反序列化的对象提供过滤！

allowed_classes 可以看成是反序列化时白名单，可以控制能够反序列化哪些对象

  1.     // 不允许反序列化任何对象
  2.     $obj =  unserialize($string, ['allowed_classes' => false]);
  4.     // 只反序列化 Class1 和 Class2
  5.     $obj =  unserialize($string, ['allowed_classes' => ['Class1', 'Class2']]);
  7.     // 默认情况下，如果没有第二个参数，则相当于 'allowed_classes'=true，也就是不管怎样都可以反序列化
  8.     $obj =  unserialize($string, ['allowed_classes' => true]);

命名空间一次性导入

可以使用 use 一次性导入同一命名空间下的类，函数，常量

  1. // PHP 7 之前的代码
  2. use some\namespace\ClassA;
  3. use some\namespace\ClassB;
  4. use some\namespace\ClassC as C;
  6. use function some\namespace\fn_a;
  7. use function some\namespace\fn_b;
  8. use function some\namespace\fn_c;
  10. use const some\namespace\ConstA;
  11. use const some\namespace\ConstB;
  12. use const some\namespace\ConstC;
  14. // PHP 7+ 及更高版本的代码
  15. use some\namespace\{ClassA, ClassB, ClassC as C};
  16. use function some\namespace\{fn_a, fn_b, fn_c};
  17. use const some\namespace\{ConstA, ConstB, ConstC};

生成器

生成器有两个新特性被引入

第一个：允许在生成器函数中通过使用 return 语法来返回一个表达式
  1. $gen = (function() {
  2.     yield 1;
  3.     yield 2;
  5.     return 3;
  6. })();
  8. foreach ($gen as $val) {
  9.     echo $val, PHP_EOL;
  10. }
  12. echo $gen->getReturn(), PHP_EOL;
  13. //1
  14. //2
  15. //3

需要注意的是，要想能够访问生成器中的返回值，必须构造一个立即调用的函数表达式

第二个：支持生成器迭代可迭代对象

生成器新增关键字 『yield from』，借助『yield from』可以迭代一个生成器，数组，可迭代对象！

  1. function outer()
  2. {
  3.     yield 1;
  4.     yield 2;
  6.     yield from [3,4];
  7.     yield from inner();
  8. }
  10. function inner()
  11. {
  12.     yield 5;
  13.     yield 6;
  14. }
  16. foreach (outer() as $val)
  17. {
  18.     echo $val, PHP_EOL;
  19. }
  20. //1
  21. //2
  22. //3
  23. //4
  24. //5
  25. //6

session 会话

session_start() 可以接受一个数组参数来对即将开启的回话进行设置，该数组的选项会覆盖 php.ini 文件中设置的会话配置选项。

例如

  1. session_start([
  2.     'cache_limiter' => 'private',
  3.     'read_and_close' => true,
  4. ]);

preg_replace_callback_array()

『preg_replace_callback()』 函数由于针对每个正则表达式都要执行回调函数，可能导致过多的分支代码，所以就有了 『preg_replace_callback_array() 』函数！

preg_replace_callback_array() 函数使用一个关联数组来对每个正则表达式注册回调函数， 正则表达式本身作为关联数组的键， 而对应的回调函数就是关联数组的值！

  1. // PHP 7 之前的代码
  2. $htmlString = preg_replace_callback(
  3.     '/(href="?)(\S+)("?)/i',
  4.     function (&$matches) {
  5.         return $matches[1] . urldecode($matches[2]) . $matches[3];
  6.     },
  7.     $htmlString
  8. );
  10. $htmlString = preg_replace_callback(
  11.     '/(href="?\S+)(%24)(\S+)?"?/i', // %24 = $
  12.     function (&$matches) {
  13.         return urldecode($matches[1] . '$' . $matches[3]);
  14.     },
  15.     $htmlString
  16. );
  18. // 使用了 PHP 7+ 后的代码
  19. $htmlString = preg_replace_callback_array(
  20.     [
  21.         '/(href="?)(\S+)("?)/i' => function (&$matches) {
  22.             return $matches[1] . urldecode($matches[2]) . $matches[3];
  23.         },
  24.         '/(href="?\S+)(%24)(\S+)?"?/i' => function (&$matches) {
  25.             return urldecode($matches[1] . '$' . $matches[3]);
  26.         }
  27.     ],
  28.     $htmlString
  29. );

 list() 函数

list 函数有了三个新特性

  • 使用数组索引赋值操作的顺序发生了变化，PHP 5 里，list() 从最右边的参数开始赋值； PHP 7 里，list() 从最左边的参数开始赋值！
  • list() 表达式不再可以完全为空！
  • 字符串无法被解析！
  1. $info = array('coffee', 'brown', 'caffeine');
  3. list($a[0], $a[1], $a[2]) = $info;
  5. // PHP 7 之前版本的代码从右边赋值
  6. var_dump($a);
  7. //array(3) {
  8. //    [2]=>
  9. //  string(8) "caffeine"
  10. //    [1]=>
  11. //  string(5) "brown"
  12. //    [0]=>
  13. //  string(6) "coffee"
  14. //}
  16. // PHP 7+ 及更高版本的代码从左边赋值
  17. var_dump($a);
  18. //[0]=>
  19. //  string(6) "coffee"
  20. //[1]=>
  21. //  string(5) "brown"
  22. //[2]=>
  23. //  string(8) "caffeine"
  24. //}

php 7.1 新特性

null 类型支持

函数参数和函数返回值可以通过在类型前加上一个问号使之允许为空。 当启用这个特性时，如果你不想给函数传参，你必须显示的传入一个null，不能啥都不传，否则会报错；

  1. function test(?string $name)
  2. {
  3.     var_dump($name);
  4. }
  6. test(null);  // null
  7. test();       //ArgumentCountError: Too few arguments to function test()

函数返回值和函数一样，你必须显示的返回一个null，否则会报错

  1. function test2(): ?string
  2. {
  3.     return null;  // null
  4.     //return ;     //即使没有值，必须显示的返回null，否则会报错Fatal error: A function with return type must return a value
  5. }
  7. var_dump(test2());

void

正如上面 null 类型中必须显示返回 null，而 void 不允许你返回 null，只允许你要么使用一个空的 return 语句，要么干脆省去 return 语句

  1. function test() : void
  2. {
  3.     //return null;  // 会报错 Fatal error: A void function must not return a value ...
  4.     return;  // 这种可以
  5. }
  6. var_dump(test());

数组解构赋值

数组解构赋值其实是 list() 函数的变体，通过 [] 来解构源数组

  1. list($n1, $n2) = [1,2];
  2. echo $n1,$n2;  // 1 2
  5. [$n1, $n2]=[1, 2];
  6. echo $n1,$n2; // 1 2

list() 函数和 解构赋值[] 支持设置键名

注意：键名必须和源数组的键名相同

  1. $data = [
  2.     ["id" => 1, "name" => 'Tom'],
  3.     ["id" => 2, "name" => 'Fred'],
  4. ];
  6. // list() 函数
  7. foreach ($data as list("id" => $id, "name" => $name))
  8. {
  9.     // TODO
  10. }
  12. //数组解构
  13. foreach ($data as ["id" => $id, "name" => $name])
  14. {
  15.     // TODO
  16. }

常量的访问控制

  1. class ConstDemo
  2. {
  3.     const PUBLIC_CONST_A = 1;
  4.     public const PUBLIC_CONST_B = 2;
  5.     protected const PROTECTED_CONST = 3;
  6.     private const PRIVATE_CONST = 4;
  7. }

iterable 对象

如果一个对象部署了 iterable 对象，就称对象是个可迭代对象，这样的一个对象就能被 foreach 遍历，并且也能被生成器的 『yield from』处理

  1. function iterator(iterable $iter)
  2. {
  3.     foreach ($iter as $val) {
  4.         //
  5.     }
  6. }

多异常捕获处理

一个catch语句块现在可以通过管道字符(|)来实现多个异常的捕获。 这对于需要同时处理来自不同类的不同异常时很有用

  1. try {
  2.     // some code
  3. } catch (FirstException | SecondException $e) {
  4.     // handle first and second exceptions
  5. }

字符串变量支持负数偏移量

字符串变量支持通过[]或{}操作字符串下标，负数意味着从字符串结尾处偏移

  1.     $a='abc';
  2.     echo $a{-1};  //c
  3.     echo $a[-1];  //c

通过 Closure::fromCallable() 将callables转为闭包

什么是callable？

一个可被调用的『正常函数』，『匿名函数』以及『类方法』都认为是 『callable』，意即可被调用；

为什么要将一个 callable 转为闭包？

当然是为了使用闭包的某些的特性，比如闭包就可以访问类的私有属性！

下面这个例子将 Test 类的私有方法 privateFunction 转成闭包后，你会发现它在类外部可以访问了

  1. class Test
  2. {
  3.     public function exposeFunction()
  4.     {
  5.         return Closure::fromCallable([$this, 'privateFunction']);
  6.     }
  8.     private function privateFunction($param)
  9.     {
  10.         var_dump($param);
  11.     }
  12. }
  14. $privFunc = (new Test)->exposeFunction();   // 私有方法被转成了闭包
  15. $privFunc('some value');

另外还需要注意的是这个 callable 到底该怎么传参的问题，该方法的传参完全可以依照 一些函数如 call_user_func() 或者 usort() 等一些支持回调参数的函数！

回调函数可以是简单函数，还可以是对象的方法，包括静态类方法

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注