递增/递减运算符

++增量运算符

--递减运算符

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

这些变量可以位于变量之前或之后。

如果放在变量之前，则首先对变量执行递增/递减操作，然后返回结果。如果放在变量之后，则首先返回变量，然后完成递增/递减操作。

例如：

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

现场示例

在上面的情况下使用，因为它更快。 会有相同的结果。++$i$i++

预增量速度要快一些，因为它确实会递增变量，然后“返回”结果。后增量创建一个特殊变量，将第一个变量的值复制到那里，并且仅在使用第一个变量后，才将其值替换为第二个变量的值。

但是，您必须使用 ，因为首先要显示当前的苹果数量，然后要从中减去一个。$apples--

您还可以在 PHP 中递增字母：

$i = "a";
while ($i < "c") {
    echo $i++;
}

一旦到达就是下一个，依此类推。zaa

请注意，字符变量可以递增，但不能递减，即使如此，也仅支持纯 ASCII 字符（a-z 和 A-Z）。

---

Stack Overflow 帖子：

• 了解递增

按位运算符

什么是位？位是 1 或 0 的表示形式。基本上是 OFF（0） 和 ON（1）

什么是字节？一个字节由 8 位组成，一个字节的最高值是 255，这意味着每个位都被设置了。我们将看看为什么字节的最大值是 255。

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

这是 1 字节的表示形式

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255（1 字节）

一些示例以便更好地理解

“AND”运算符：&

$a =  9;
$b = 10;
echo $a & $b;

这将输出数字 8。为什么？好吧，让我们看看使用我们的表格示例。

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
------------------------------------------- 

因此，您可以从表中看到它们共享的唯一位是 8 位。

第二个例子

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

两个共享位是 32 和 4，当它们相加时返回 36。

“Or”运算符：|

$a =  9;
$b = 10;
echo $a | $b;

这将输出数字 11。为什么？

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

您会注意到，我们在 8、2 和 1 列中设置了 3 位。把它们加起来：8+2+1=11。

_ gettext（） 的别名

下划线字符 '_' as in 是 gettext（） 函数的别名。_()

魔术常数：尽管这些不仅仅是符号，而是这个代币家族的重要组成部分。有八个神奇的常数会根据它们的使用地点而变化。

__LINE__：文件的当前行号。

__FILE__：文件的完整路径和文件名。如果在包含中使用，则返回包含文件的名称。从 PHP 4.0.2 开始，始终包含一个解析符号链接的绝对路径，而在旧版本中，它在某些情况下包含相对路径。__FILE__

__DIR__：文件的目录。如果在 include 中使用，则返回包含文件的目录。这相当于 。除非是根目录，否则此目录名称没有尾部斜杠。（在 PHP 5.3.0 中添加。dirname(__FILE__)

__FUNCTION__：函数名称。（在 PHP 4.3.0 中添加）从 PHP 5 开始，这个常量返回声明时的函数名称（区分大小写）。在 PHP 4 中，它的值始终是小写的。

__CLASS__：类名。（在 PHP 4.3.0 中添加）从 PHP 5 开始，这个常量返回声明时的类名（区分大小写）。在 PHP 4 中，它的值始终是小写的。类名包括声明它的命名空间（例如）。请注意，从 PHP 5.4 开始，在 traits 中也有效。在 trait 方法中使用时，是使用该 trait 的类的名称。Foo\Bar__CLASS____CLASS__

__TRAIT__：特征名称。（在 PHP 5.4.0 中添加）从 PHP 5.4 开始，这个常量返回声明时的特征（区分大小写）。特征名称包括声明它的命名空间（例如）。Foo\Bar

__METHOD__：类方法名称。（在 PHP 5.0.0 中添加）方法名称在声明时返回（区分大小写）。

__NAMESPACE__：当前命名空间的名称（区分大小写）。这个常量是在编译时定义的（在 PHP 5.3.0 中添加）。

源

类型运算符

instanceof用于判断 PHP 变量是否为某个类的实例化对象。

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

上面的例子将输出：

bool(true)
bool(false)

原因：上面的示例是一个对象，因此仅使用一个数据而不是实例$amclassmclasssclass

继承示例

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

上面的例子将输出：

bool(true)
bool(true)

克隆示例

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

上面的例子将输出：

bool(true)
bool(true)

<=>宇宙飞船操作员

添加到 PHP 7 中

宇宙飞船算子是 PHP 7 中最新添加的比较算子。它是一个非关联二元运算符，其优先级与相等运算符 （， ， ， ） 相同。此运算符允许在左手和右手操作数之间进行更简单的三向比较。<=>==!====!==

运算符生成以下整数表达式：

• 0当两个操作数相等时
• 小于左操作数小于右操作数时0
• 大于左操作数大于右操作数时0

例如

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

使用此运算符的一个很好的实际应用是在比较类型回调中，这些回调应根据两个值之间的三向比较返回零、负或正整数。传递给 usort 的比较函数就是这样一个例子。

在 PHP 7 之前，你会写...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

从 PHP 7 开始，您可以编写...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
    // return $b <=> $a; // for reversing order
});

宇宙飞船操作员 <=> （在 PHP 7 中添加）

<=> 宇宙飞船操作员的示例（PHP 7，来源：PHP 手册）：

整数、浮点数、字符串、数组和对象，用于变量的三向比较。

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 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
// Comparison is case-sensitive
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; // 1

{}大括号

• 块 - 大括号/无大括号？
• PHP 中字符串中的大括号
• 数组表示法中的 PHP 大括号

关于上一篇文章的一些话

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works

PHP字符串：PHP 字符串可以通过四种方式指定，而不仅仅是两种方式：

1） 单引号字符串：

$string = 'This is my string'; // print This is my string

2） 双引号字符串：

$str = 'string';

$string = "This is my $str"; // print This is my string

3） Heredoc：

$string = <<<EOD
This is my string
EOD; // print This is my string

4） Nowdoc（从 PHP 5.3.0 开始）：

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string

PHP 中的运算符概述：

---

逻辑运算符：

• $a & & $b ：如果 $a 和 $b 都为 TRUE，则为 TRUE。
• $a || $b ：如果 $a 或 $b为 TRUE，则为 TRUE。
• $a xor $b ：如果 $a 或 $b 为 TRUE，则为 TRUE，但不能同时为两者。
• ！ $a ：如果 $a 不是 TRUE，则为 TRUE。
• $a和$b：如果 $a 和 $b 都为 TRUE，则为 TRUE。
• $a或$b ：如果 $a 或 $b为 TRUE，则为 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，则为 TRUE。
• $a <=> $b ：当$a分别小于、等于或大于 $b 时，小于、等于或大于零的整数。从 PHP 7 开始可用。
• $a ？ $b ： $c ： 如果$a返回$b否则返回$c（三元运算符)
• $a ？？ $c ： 和$a一样？$a ： $c （空合并运算符 - 需要 PHP>=7）

---

算术运算符：

• -$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次方的结果（在 PHP 5.6 中引入）

---

递增/递减运算符：

• ++$a ：$a递增 1，然后返回 $a。
• $a++ ：返回$a，然后逐$a递增。
• --$a ：递减 $a 1，然后返回 $a。
• $a-- ：返回$a，然后递减$a 1。

---

按位运算符：

• $a & $b ：设置了在$a和$b中设置的位。
• $a | $b ：设置在$a或$b中设置的位。
• $a ^ $b ：设置了 $a 或 $b 但未同时设置的位。
• ~ $a ： 在$a中设置的位未设置，反之亦然。
• $a << $b：将$a $b步的位向左移动（每步表示“乘以二”）
• $a >> $b：将$a $b步的位向右移动（每步的意思是“除以二”）

---

字符串运算符：

• $a . $b ： $a 和 $b 的串联。

---

数组运算符：

• $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。

---

赋值运算符：

• $a = $b ：将 $b 的值分配给$a
• $a += $b ： 与 $a = $a + $b 相同
• $a -= $b ： 与 $a = $a - $b 相同
• $a *= $b ： 与 $a = $a * $b 相同
• $a /= $b ： 与 $a = $a / $b 相同
• $a %= $b ： 与 $a = $a % $b 相同
• $a **= $b ： 与 $a = $a ** $b 相同
• $a .= $b ： 与 $a = $a 相同。$b
• $a &= $b ： 与 $a = $a & $b 相同
• $a |= $b ： 与 $a = $a 相同 |$b
• $a ^= $b ： 与 $a = $a ^ $b 相同
• $a <<= $b ： 与 $a = $a << $b 相同
• $a >>= $b ： 与 $a = $a >> $b 相同
• $a ？？= $b ：如果 $b 的值为 null 或未定义，则将$a值分配给 $a（null 合并赋值运算符 - 需要 PHP>=7.4）

---

注意

and运算符和运算符的优先级低于赋值运算符。or=

这意味着这等价于 .$a = true and false;($a = true) and false

在大多数情况下，您可能希望使用 && 和 ||，它们的行为方式与 C、Java 或 JavaScript 等语言相似。

问题：

什么意思？=>

---

答：

=>是我们人类决定用来分隔关联数组中对的符号。"Key" => "Value"

阐述：

要理解这一点，我们必须知道什么是关联数组。当传统程序员想到数组（在PHP中）时，首先想到的是：

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

如果我们想在代码的后面部分调用数组，我们可以这样做：

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

目前为止，一切都好。但是，作为人类，我们可能很难记住数组的索引是 2016 年的值，数组的索引是问候语，数组的索引是简单的整数值。然后，我们将拥有的替代方案是使用所谓的关联数组。关联数组与顺序数组有一些区别（这是前面的情况，因为它们通过增加每个后续值 1 来增加预定序列中使用的索引）。[0][1][2]

差异（顺序数组和关联数组之间）：

• 在声明关联数组时，您不仅要包含要放入数组的内容，而且还要在代码的后面部分中放置调用数组时要使用的索引值（称为 ）。在声明期间使用以下语法：.valuekey"key" => "value"

• 使用关联数组时，该值将被放置在数组的索引内，以检索所需的 .keyvalue

例如：

$myArray1 = array( 
    "Year" => 2016, 
    "Greetings" => "hello", 
    "Integer_value" => 33);//option 1

$myArray2 = [ 
    "Year" =>  2016, 
    "Greetings" => "hello", 
    "Integer_value" => 33];//option 2

$myArray3 = [];//option 3
$myArray3["Year"] = 2016; 
$myArray3["Greetings"] = "hello"; 
$myArray3["Integer_value"] = 33;

现在，为了接收与以前相同的输出，该值将在数组索引中使用：key

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

最后一点：

因此，从上面的例子中可以很容易地看出，在数组中的值启动期间，该符号用于表示数组中每个 和 对之间的关联数组之间的关系。=>keyvalue

空合并运算符 （？？）

PHP 7.0 中添加了此运算符，用于需要将三元运算符与 结合使用的常见情况。如果它存在并且不存在，则返回其第一个操作数;否则，它将返回其第二个操作数。isset()NULL

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>

问题：

PHP中的“&”是什么意思？

PHP“&”运算符

一旦我们习惯了它，就会让生活更轻松。（请仔细检查下面的示例）

&通常检查在$a中设置的位，并设置$b。

你有没有注意到这些电话是如何工作的？

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

因此，上述所有操作的背后是按位运算符和位的游戏。

其中一个有用的例子是简单的配置，如下所示，因此单个整数字段可以为您存储数千个组合。

大多数人已经阅读了文档，但并没有重新了解这些按位运算符的真实用例。

你会喜欢的例子

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird

==用于检查相等性，而不考虑变量数据类型

===用于检查变量值和数据类型的相等性

例

$a = 5

1. if ($a == 5)- 将评估为 true

2. if ($a == '5')- 将计算结果为 true，因为在比较这两个值时，PHP 会在内部将该字符串值转换为整数，然后比较这两个值

3. if ($a === 5)- 将评估为 true

4. if ($a === '5')- 将计算结果为 false，因为 value 为 5，但此值 5 不是整数。

Null Coalesce 运算符 “？？”（在 PHP 7 中添加）

对于运算符来说，这不是最吸引人的名字，但 PHP 7 引入了相当方便的 null 合并，所以我想我会分享一个例子。

在 PHP 5 中，我们已经有一个三元运算符，它测试一个值，如果返回 true，则返回第二个元素，如果不返回，则返回第三个元素：

echo $count ? $count : 10; // outputs 10

还有一个简写，如果它与第一个元素相同，则允许您跳过第二个元素：echo $count ？： 10;同时输出 10

在 PHP 7 中，我们还得到了 ？？运算符，而不是表示极度混乱，这是我通常同时使用两个问号的方式，而是允许我们将一串值链接在一起。从左到右读取，第一个存在且不为 null 的值是将返回的值。

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

此构造可用于优先考虑可能来自用户输入或现有配置的一个或多个值，并在缺少该配置时安全地回退到给定的默认值。这是一个很小的功能，但我知道一旦我的应用程序升级到 PHP 7，我就会使用它。

可为 null 的返回类型声明

PHP 7 增加了对返回类型声明的支持。与参数类型声明类似，返回类型声明指定将从函数返回的值的类型。返回类型声明的可用类型与参数类型声明的可用类型相同。

严格类型化也会影响返回类型声明。在默认的弱模式下，如果返回的值还不是该类型，则它们将被强制转换为正确的类型。在强模式下，返回值的类型必须正确，否则将抛出 TypeError。

从 PHP 7.1.0 开始，可以通过在类型名称前面加上问号 （？） 来将返回值标记为可为 null。这表示该函数返回指定的类型或 NULL。

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

源

三个 DOTS 作为 Splat 算子 （...）（从 PHP 5.6 开始）

PHP 有一个运算符“...”（三个点），称为 Splat 运算符。它用于在函数中传递任意数量的参数，这种类型的函数称为可变参数函数。让我们举例说明“...”的用法（三个点）。

示例 1：

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
 
echo calculateNumbers(10, 20, 30, 40, 50);
 
//Output 150
?>

calculateNumbers（） $params函数的每个参数在使用“...".

有许多不同的方法可以使用“...“运算符。以下是一些示例：

示例 2：

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}
 
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);
 
//Output 150
?>

示例 3：

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);
 
//Output 220
?>

示例 4：

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
 
$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);
 
//Output 1650
 
?>

应该注意的是，可变参数不能由命名参数作为目标。

示例 5：

<?php
function sumIntegers(int ...$params): int {
    $sum = 0;
    foreach($params as $value){
        $sum += $value;
    }
    return $sum;
}


echo sumIntegers(params: [1, 2, 3, 4]);     
// $params will be equal to ['params' => [1, 2, 3, 4]] in sumIntegers
// throws TypeError sumIntegers(): Argument #1 must be of type int, array given 

echo sumIntegers(arbitrary_name: 1, another_name: 2);
// $params will be equal to ['arbitrary_name' => 1, 'another_name' => 2] in sumIntegers
// Outputs: 3 
?>

使用解压缩的关联数组作为函数调用的参数与使用每个键值对作为命名参数调用函数的效果相同。

示例 6：

<?php
function fullName(string $first_name, ?string $middle_name = null, ?string $last_name = null): string {
    return trim("$first_name|$middle_name|$last_name");
}

$params = ['first_name' => 'John', 'last_name' => 'Doe'];
echo fullName(...$params);
// same as fullName(first_name: 'John', last_name: 'Doe')

// outputs 'John||Doe'
?>

这可用于将命名参数传递给嵌套函数调用或类之类的内容。

示例 7：

<?php
function throw_exception(string $exception, ...$parameters) {
    throw new $exception(...$parameters);
}

throw_exception(exception: 'Exception', code: 123);
// executes throw new Exception(...['code' => 123])
// which is the same as throw new Exception(code: 123);
?>

？-> NullSafe 运算符

PHP 8.0 新增

它是 NullSafe 运算符，如果您尝试调用函数或从 .Nullsafe 运算符可以链接，并且可以在方法和属性上使用。nullnull

$objDrive = null;
$drive = $objDrive?->func?->getDriver()?->value; //return null
$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object

Nullsafe 运算符不适用于数组键：

$drive['admin']?->getDriver()?->value //Warning: Trying to access array offset on value of type null

$drive = [];
$drive['admin']?->getAddress()?->value //Warning: Undefined array key "admin"

NullSafe 运算符 “？->” 从 php8 开始

在 PHP8 中，这个新运算符已被接受，您可以在此处找到文档。 它是 ，如果您尝试调用函数或从中获取值，它会返回......?->NullSafe Operatornullnull

例子：

<?php
$obj = null;
$obj = $obj?->attr; //return null
$obj = ?->funct(); // return null
$obj = $objDrive->attr; // Error: Trying to get property 'attr' of non-object
?>

在php 8中

与其编写经典代码，不如使用运算符只编写 1 行代码，代码变得非常清晰：!== null?

以前：

$firsName =  null;
if ($session !== null) {
    $user = $session->user;
    if ($user !== null) {
        $name = $user->getName();
        if ($name !== null) {
            $firstName = $name->firstName;
        }
    }
}

后：

$firsName = $session?->user?->getName()?->firstName;

使用代替 .该表达式改用严格的比较 （）。无论 .matchswitchmatch===strict_types

以前：

switch ('A') {
    case 'A':
        echo "found A";
        break;
    case 'B':
        echo "found B";
        break;
}
// Result: "found A"

后：

echo match ('A') {
  'A' => "found A",
  'B' => "found B",
};
// Result: "found A"

#[] 属性从 PHP 8 开始

从 PHP 8 开始，你就可以写了。这是 PHP（也是 Rust 和 C#）中的一个属性。其他语言可能会使用注释 （Java） 或装饰器（Python、Javascript）等名称来实现类似的功能。在 PHP 8 之前，在行尾之前一直是一个注释（因为在 PHP 中开始一个注释）。因此，如果一个属性是一行的最后一件事，那么在 PHP 8 之前的版本中它将被忽略。如果不是一行的最后一件事，它会注释掉 PHP 8 之前它后面的任何内容（从那时起终止了它）。#[attribute_name]#[whatever]#]

• RFC的
• 语法 RFC（语法已从原始 RFC 更改）
• 文档

双点语法

在限定的本机 PHP 字符串函数中，在两个字符之间使用时，用于表示包含字符的范围。 等同于 。..a-eabcde

echo trim('adobe', 'a..e');

指纹：

o

允许双点范围语法的本机 PHP 函数

PHP中的\（反斜杠）符号是什么

它用于转义字符串类型或更改特定大小写：

例子：

这里 \r\n 和 \n 用于传递到新行（如回车按钮）

echo "Hello world \n\r I am Herakl";

或者，您可以使用PHP_EOL。但也有一些例外。首先，它只能在两个引号（“）条件下使用。此外，它是逃避自我

echo " Hello \\ I am robot";

在 stackoverflow 中，它无法正确看到。

反斜杠也用于命名空间或使用条件名称：

namespace App\Http\Controllers;

use App\Models;

此外，您应该访问有关斜杠 https://www.php.net/manual/en/function.addslashes.php

第一类可调用语法 （PHP 8.1）

省略号 （） 在 PHP8.1 中引入了另一种用途，用于从可调用对象创建匿名函数...

PHP 8.1 之前的版本

$callable = [$instance, 'someMethod'];

在 PHP 8.1 中

$callable = $instance->someMethod(...);

在这里阅读更多关于它的信息