参考 - 这个符号在 PHP 中是什么意思?

这是什么?

这是有关 PHP 语法的不时出现的问题的集合。这也是一个社区 Wiki,因此邀请所有人参与维护此列表。

为什么是这样?

过去很难找到有关运算符和其他语法标记的问题。¹
主要思想是链接到 Stack Overflow 上的现有问题,因此我们更容易引用它们,而不必复制 PHP 手册中的内容。

注意:自 2013 年 1 月起,Stack Overflow 确实支持特殊字符 。只需用引号将搜索词引起来,例如[php] "==" vs "==="

我该怎么办?

如果有人因提出这样的问题而将您指向此处,请在下面找到特定的语法。 PHP 手册的链接页面以及链接的问题可能会回答您的问题。如果是这样,建议您增加答案。此列表不能代替其他人提供的帮助。

名单

如果您的特定令牌未在下面列出,则可以在解析器令牌列表中找到它。


& 按位运算符引用


=& 参考


&= 按位运算符


&& 逻辑运算符


% 算术运算符


!! 逻辑运算符


@ 错误控制运算符


?: 三元运算符


?? 空合并运算符 (自 PHP 7 起)


?string ?int ?array ?bool ?float 可空的返回类型声明 (自 PHP 7.1 起)


: 控制结构的替代语法三元运算符


:: 范围解析运算符


\ 命名空间


-> 类和对象


=> 数组


^ 按位运算符


>> 按位运算符


<< 按位运算符


<<< Heredoc 或 Nowdoc


= 分配运算符


== 比较运算符


=== 比较运算符


!== 比较运算符


!= 比较运算符


<> 比较运算符


<=> 比较运算符 (自 PHP 7.0)


| 按位运算符


|| 逻辑运算符


~ 按位运算符


+ 算术运算符数组运算符


+=-= 赋值运算符


++-- 递增 / 递减运算符


.= 赋值运算符


. 字符串运算符


, 功能参数

, 变量声明


$$ 变量变量


` 执行运算符


<?= 短标签


[] 数组 (自 PHP 5.4 起的简短语法)


<? 开启和关闭标签


... 参数解压缩 (自 PHP 5.6 起)


** (自 PHP 5.6 起)


# 单行 shell 样式的注释


:? 可空的返回类型


答案

递增 / 递减运算符

++增量运算符

--递减运算符

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++;
}

一旦到达z则下一个是aa ,依此类推。

请注意,字符变量可以递增但不能递减,即使如此,仅支持纯 ASCII 字符(az 和 AZ)。


堆栈溢出帖子:

按位运算符

有什么?位表示 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。

该 “或” 运算符: |

$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()的别名

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

Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
                            in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
                           (x < 10 and y > 1) returns true 
x && y    And              True if both x and y are true x=6 y=3
                           (x < 10 && y > 1) returns true
x or y     Or              True if any of x or y are true x=6 y=3
                           (x < 10 or y > 10) returns true 
x || y     Or              True if any of x or y are true x=6 y=3
                           (x < 3 || y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"

<=>太空飞船运营商

在 PHP 7 中添加

太空飞船运算符 <=>是 PHP 7 中添加的最新比较运算符。它是非关联二进制运算符,其优先级与相等运算符( ==!====!== )相同。此运算符允许在左侧和右侧操作数之间进行更简单的三向比较。

运算符的整数表达式为:

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

例如

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

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

在 PHP 7 之前,您需要编写...

$arr = array(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;
});

魔术常数 :尽管这些常数不仅是符号,而且是此令牌系列的重要组成部分。有八个神奇常数会根据使用的位置而变化。

__LINE__ :文件的当前行号。

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

__DIR__ :文件目录。如果在 include 中使用,则返回包含文件的目录。这等效于dirname(__FILE__) 。除非它是根目录,否则此目录名称不带斜杠。 (在 PHP 5.3.0 中添加。)

__FUNCTION__ :函数名称。 (在 PHP 4.3.0 中添加)从 PHP 5 开始,此常量返回声明的函数名称(区分大小写)。在 PHP 4 中,其值始终为小写。

__CLASS__ :类名称。 (在 PHP 4.3.0 中添加)从 PHP 5 开始,此常量返回声明的类名(区分大小写)。在 PHP 4 中,其值始终为小写。类名称包括在其中声明的名称空间(例如Foo\Bar )。请注意,自 PHP 5.4 起, __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)

原因:上面的示例$amclass的对象,因此仅使用mclass数据,而不使用sclass实例

继承的例子

<?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 运算符概述:


逻辑运算符:

  • $ 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 加 1。
  • -$ a :将 $ a 减一,然后返回 $ a。
  • $ a-- :返回 $ a,然后将 $ a 减 1。

按位运算符:

  • $ a&$ b :设置在 $ a 和 $ b 中设置的位。
  • $ a | $ b :设置在 $ a 或 $ b 中设置的位。
  • $ a ^ $ b :$ a 或 $ b 中设置的位,但未同时设置。
  • 〜$ a :未设置在 $ a 中设置的位,反之亦然。
  • $ a << $ b :将 $ a $ b 步骤的位向左移动(每个步骤表示 “乘以 2”)
  • $ 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 相同

注意

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

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

在大多数情况下,您可能需要使用&&|| ,其行为方式可从 C,Java 或 JavaScript 等语言得知。

太空飞船运营商<=> (PHP 7 中添加)

<=> Spaceship 运算符的示例(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

{}花括号

还有关于最后一个帖子的一些话

$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