it-swarm.cn

怎么办 PHP 等式(== double equals)和identity(=== triple equals)比较运算算有何不同?

=====有什么区别?

  • 松散的==比较究竟是如何工作的?
  • 严格的===比较究竟是如何工作的?

什么是有用的例子?

463
nickf

=====之间的区别

松散==相等运算符和严格===相同运算符之间的区别在 manual 中有详细解释:

比较运算符

┌──────────┬───────────┬───────────────────── ──────────────────────────────────────────────────────────────────────────────────────────────────────── │
├──────────┼───────────┼──────────────────── ──────────────────────────,= a == $b│Equal│如果在类型杂耍后$ a等于$ b,则为TRUE。 │
│$ a === $b│相同│如果$ a等于$ b,则为TRUE,它们属于同一类型。 │
└──────────┴───────────┴──────────────────── ───────────────────────────────────────┘

松散地==等于比较

如果您使用的是==操作,或者使用松散的比较如!=<>==任何其他比较运算,你总是要看看 情境 看什么,在哪里,以及为什么一些被转换成了解发生了什么。

转换规则

类型比较表

作为参考和示例,您可以在 manual 中看到比较表:

==的松散比较

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐
││TRUE FALSE││1│0│-1│ “1” │ “0” │ “-1” │NULL│阵列()│ “PHP” │ “”│
├──────────────────────────────── ┼───────┼───────┼───────┼───────┼───────┼───────── ┼───────┼───────┤
│TRUE TRUE││FALSE TRUE││FALSE TRUE││TRUE FALSE││TRUE FALSE││FALSE TRUE││FALSE│
│错误│错误│正确│FALS E│TRUE│FALSE│FALSE│TRUE│FALSE│TRUE│TRUE│FALSE│TRUE│
│1│TRUE│FALSE│TRUE│FALSE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│假│
│0│假│正确│错误│正确│错误│错误│正确│错误│正确│错误│正确│正确│
│-1│正确│错误│错误│虚假│正确│错误│错误│正确│错误│错误│错误│错误│
│“1”│正确│错误│正确│错误│错误│正确│错误│错误│错误│错误│错误│虚假│
│“0”│失败│正确│错误│正确│错误│错误│正确│错误│错误│错误│错误│错误│
│“-1”│正确│错误│ FALSE FALSE││TRUE FALSE││FALSE TRUE││FALSE FALSE││FALSE FALSE││
│NULL│FALSE│ TRUE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│TRUE│TRUE│FALSE│TRUE│
│array()│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│TRUE│ TRUE│FALSE│FALSE│
│“php”│TRUE│FALSE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│UEUE│FALSE│
│“”│FALSE │TRUE FALSE││TRUE FALSE││FALSE FALSE││FALSE TRUE││FALSE FALSE││TRUE│
└─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘

严格的===完全相同的比较

如果您正在使用===运算符,或使用严格比较的任何其他比较运算符,例如!=====,那么您始终可以确保类型不会神奇地更改,因为不会有转换继续因此,通过严格比较,类型和值必须相同,而不仅仅是值。

类型比较表

作为参考和示例,您可以在 manual 中看到比较表:

===严格比较

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐
││TRUE FALSE││1│0│-1│ “1” │ “0” │ “-1” │NULL│阵列()│ “PHP” │ “” │
├─────────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼───────┼───────── ┼───────┼───────┤
│TRUE TRUE││FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE│
│错误│错误│正确│FALS E│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│
│1│FALSE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│ FALSE│
│0│FALSE FALSE││FALSE TRUE││FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││
│-1│FALSE FALSE││FALSE FALSE│ │TRUE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││
│ “1” │FALSE FALSE││FALSE FALSE││FALSE TRUE││FALSE FALSE││FALSE FALSE││FALSE FALSE│ │
│ “0” │FALSE FALSE││FALSE FALSE││FALSE FALSE││TRUE FALSE││FALSE FALSE││FALSE FALSE││
│ “-1” │FALSE FALSE││ FALSE FALSE││FALSE FALSE││FALSE TRUE││FALSE FALSE││FALSE FALSE││
│NULL│FALSE│ FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE TRUE││FALSE FALSE││FALSE│
│阵列()│FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE│ TRUE FALSE││FALSE│
│ “PHP” │FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││TRUE FALSE││
│ “” │FALSE │FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││FALSE FALSE││TRUE│
└─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘
588
nickf

如果运算符不同,则运算符==在两种不同类型之间进行转换,而===运算符执行“类型安全比较”。这意味着如果两个操作数具有相同的类型和相同的值,它将仅返回true。

例子:

1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value

警告 :具有等效成员的同一类的两个实例与===运算符不匹配。例:

$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)
236
Patrick Glandien

一张图片胜过千言万语:

PHP Double Equals ==平等图:

enter image description here

PHP Triple Equals ===平等图表:

enter image description here

创建这些图像的源代码:

https://github.com/sentientmachine/php_equality_charts

大师冥想

那些希望保持理智的人,不要再读了,因为这些都没有任何意义,只是说这是PHP的疯狂分形是如何设计的。

  1. NAN != NAN但是NAN == true
  2. 如果left是数字,==会将左右操作数转换为数字。所以123 == "123foo",但"123" != "123foo"
  3. 引号中的十六进制字符串偶尔会是一个浮点数,并且会被意外转换为违背您的意愿浮动,从而导致运行时错误。

  4. ==不可传递,因为"0"== 00 == ""但是"0" != ""

  5. 尚未声明的PHP变量为false,即使PHP有表示未定义变量的方法,该功能也被==禁用。
  6. "6" == " 6""4.2" == "4.20""133" == "0133"但是133 != 0133。但"0x10" == "16""1e3" == "1000"暴露出意外的字符串转换为八进制将在没有您的指示或同意的情况下发生,从而导致运行时错误。

  7. False == 0""[]"0"

  8. 当数字足够大时,它们是==无穷大。

  9. 一个新的类是==到1。

  10. False是最危险的值,因为对于大多数其他变量,False ==,大多数都是为了破坏它的目的。

希望:

如果你使用PHP,你不应该使用double equals运算符,因为如果你使用三等于,那么唯一要担心的Edge情况是NAN和数字如此接近无穷大以至于它们被转换为无穷大。使用双等号,任何东西都可以是==任何东西,或者可能会出乎意料地将你的意志和!=强加给它显然应该相等的东西。

你在PHP中使用==的任何地方都是一个糟糕的代码味道,因为隐含的强制转换规则暴露了85个错误,似乎是由数百万程序员通过布朗运动编程设计的。

65
Eric Leschinski

关于JavaScript:

===运算符与==运算符的作用相同,但它要求其操作数不仅具有相同的值,而且还具有相同的数据类型。

例如,下面的示例将显示'x和y相等',但不是'x和y相同'。

var x = 4;
var y = '4';
if (x == y) {
    alert('x and y are equal');
}
if (x === y) {
    alert('x and y are identical');
}
39
user1684

关于对象比较的其他答案的补充:

==使用对象的名称及其值来比较对象。如果两个对象具有相同的类型且具有相同的成员值,则$a == $b将返回true。

===比较对象的内部对象id。即使成员相等,$a !== $b如果它们不是完全相同的对象。

class TestClassA {
    public $a;
}

class TestClassB {
    public $a;
}

$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();

$a1->a = 10;
$a2->a = 10;
$b->a = 10;

$a1 == $a1;
$a1 == $a2;  // Same members
$a1 != $b;   // Different classes

$a1 === $a1;
$a1 !== $a2; // Not the same object
22
soulmerge

简单来说:

==检查是否 等效 (仅限值)

===检查 same (value && type)


等效与相同:类比

1 + 1 = 2 + 0 (等效)

1 + 1 = 1 + 1 (相同)


在PHP中:

true == 1 (true - 等值)

true === 1 (false - 值&&类型不一样)

  • true是 boolean
  • 1是 int
13
silver

这都是关于数据类型的。以BOOL(真或假)为例:

true也等于1false也等于0

==在比较时不关心数据类型:所以如果你有一个变量1(也可能是true):

$var=1;

然后与==进行比较:

if ($var == true)
{
    echo"var is true";
}

$var实际上并不等于true,是吗?它具有1的int值,而后者又等于true。

使用===,将检查数据类型以确保两个变量/对象/使用相同类型的任何内容。

所以,如果我这样做

if ($var === true)
{
    echo "var is true";
}

那条件不会是真的,因为$var !== true只有== true(如果你知道我的意思)。

你为什么需要这个?

简单 - 让我们来看看PHP的一个函数:array_search()

array_search()函数只是在数组中搜索一个值,并返回找到该值的元素的键。如果在数组中找不到该值,则返回false。但是,如果你对存储在数组的第一个元素(它将具有0的数组键)的值上执行了array_search(),那么array_search()函数将返回0 ...这等于假..

所以,如果你这样做:

$arr = array("name");
if (array_search("name", $arr) == false)
{
    // This would return 0 (the key of the element the val was found
    // in), but because we're using ==, we'll think the function
    // actually returned false...when it didn't.
}

所以,你现在看到这可能是一个问题吗?

在检查函数是否返回false时,大多数人不使用== false。相反,他们使用!。但实际上,这与使用==false完全相同,所以如果你这样做了:

$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)

因此,对于类似的事情,您将使用===,以便检查数据类型。

8
user849137

一个例子是数据库属性可以为null或“”:

$attributeFromArray = "";
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //true
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //false

$attributeFromArray = null;
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //false
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //true
8
fico7489

给定x = 5

1)运算符:==“等于”。 x == 8是假的
2)运算符:===“完全等于”(值和类型)x === 5为真,x === "5"为false

6
Mannusanghi

几个例子

var_dump(5 == 5);    // True
var_dump(5 == "5");  // True because == checks only same value not type
var_dump(5 === 5);   // True
var_dump(5 === "5"); // False because value are same but data type are different.

附:.

==仅比较值,它不会打扰数据类型

vs.

===比较值和数据类型

4
Mohit Tanwani

简而言之,===的工作方式与大多数其他编程语言中的==相同。

PHP允许您进行真正有意义的比较。例:

$y = "wauv";
$x = false;
if ($x == $y)
    ...

虽然这允许一些有趣的“快捷方式”,但你应该注意,因为一个不应该返回的东西(比如“错误”而不是数字)不会被捕获,你会想知道发生了什么。

在PHP中,==比较值并在必要时执行类型转换(例如,字符串“12343sdfjskfjds”将在整数比较中变为“12343”)。 ===将比较值AND类型,如果类型不相同则返回false。

如果查看PHP手册,你会看到很多函数在函数失败时返回“false”,但是在成功的场景中它们可能会返回0,这就是为什么他们建议做“if” function()!== false)“以避免错误。

3
Christian P.
$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

但要小心。这是一个臭名昭着的问题。

// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
    // code...
}

vs.

// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
    // code...
}
3
Seph

PHP是一种松散类型的语言。使用双等运算符可以对变量进行宽松的检查。

松散地检查一个值将允许一些相似但不相等的值等同于:

  • “”
  • 空值
  • false

使用双等运算符,所有这些值都等于相等。

2
Cory Collier

您可以使用===来测试函数或变量是否为false而不是仅等于false(零或空字符串)。

$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
    echo $needle . ' was not found in ' . $haystack;
} else {
    echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}

在这种情况下,strpos将返回0,这将在测试中等于false

if ($pos == false)

要么

if (!$pos)

这不是你想要的。

2
Stacey Richards

至于何时使用另一个,请以PHP中的fwrite()函数为例。

此函数将内容写入文件流。根据PHP,“fwrite()返回写入的字节数,或者错误时返回FALSE。”。如果要测试函数调用是否成功,则此方法存在缺陷:

if (!fwrite(stuff))
{
    log('error!');
}

它可以返回零(并且被认为是成功的),并且您的状况仍然会被触发。正确的方法是:

if (fwrite(stuff) === FALSE)
{
    log('error!');
}
2
Mario

php ==是一个比较运算符,用于比较变量的值。但是===比较值和数据类型。

例如,

<?php 
  $var1 = 10;
  $var2 = '10';

  if($var1 == $var2) {
    echo 'Variables are equal';
  } else {
    echo 'Variables are not equal';
  }
?>

在这种情况下,输出将是“变量相等”,即使它们的数据类型不同。

但是如果我们使用===而不是==,输出将是'变量不相等'。 php首先比较变量的值然后比较数据类型。这里的值相同,但数据类型不同。

1
2rahulsk

到目前为止,所有答案都忽略了===的危险问题。已经注意到,但是没有强调,integer和double是不同的类型,因此以下代码:

$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n ==  $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );

得到:

 equal
 not equal

请注意,这不是“舍入错误”的情况。这两个数字完全相同,直到最后一位,但它们有不同的类型。

这是一个令人讨厌的问题,因为如果所有数字足够小(使用“足够小”取决于您运行的硬件和操作系统),使用===的程序可以快乐地运行多年。但是,如果偶然,整数恰好大到足以转换为double,则其类型将“永久”更改,即使后续操作或许多操作可能会将其返回到值中的小整数。而且,它变得更糟。它可以传播 - 双重感染可以传递到它触及的任何东西,一次一个计算。

例如,在现实世界中,这可能是处理2038年以后日期的程序中的问题。此时,UNIX时间戳(自1970-01-01 00:00:00 UTC以来的秒数)将需要超过32位,因此它们的表示将在某些系统上“神奇地”切换为双精度。因此,如果计算两次之间的差异,可能会以几秒钟结束,但作为一个双倍,而不是2017年发生的整数结果。

我认为这比字符串和数字之间的转换要糟糕得多,因为它很微妙。我发现很容易跟踪什么是字符串和什么是数字,但是跟踪数字中的位数是超出我的。

因此,在上面的答案中有一些Nice表,但没有区分1(作为整数)和1(微妙的双)和1.0(明显的双)。此外,建议您应该始终使用===和never ==并不是很好,因为===有时会失败,其中==正常工作。此外,JavaScript在这方面并不相同,因为它只有一种数字类型(在内部它可能有不同的逐位表示,但它不会导致===的问题)。

我的建议 - 两者都不用。你需要编写自己的比较函数来真正解决这个问题。

1
DavidWalley
<?php

    /**
     * Comparison of two PHP objects                         ==     ===
     * Checks for
     * 1. References                                         yes    yes
     * 2. Instances with matching attributes and its values  yes    no
     * 3. Instances with different attributes                yes    no
     **/

    // There is no need to worry about comparing visibility of property or
    // method, because it will be the same whenever an object instance is
    // created, however visibility of an object can be modified during run
    // time using ReflectionClass()
    // http://php.net/manual/en/reflectionproperty.setaccessible.php
    //
    class Foo
    {
        public $foobar = 1;

        public function createNewProperty($name, $value)
        {
            $this->{$name} = $value;
        }
    }

    class Bar
    {
    }
    // 1. Object handles or references
    // Is an object a reference to itself or a clone or totally a different object?
    //
    //   ==  true   Name of two objects are same, for example, Foo() and Foo()
    //   ==  false  Name of two objects are different, for example, Foo() and Bar()
    //   === true   ID of two objects are same, for example, 1 and 1
    //   === false  ID of two objects are different, for example, 1 and 2

    echo "1. Object handles or references (both == and    ===) <br />";

    $bar = new Foo();    // New object Foo() created
    $bar2 = new Foo();   // New object Foo() created
    $baz = clone $bar;   // Object Foo() cloned
    $qux = $bar;         // Object Foo() referenced
    $norf = new Bar();   // New object Bar() created
    echo "bar";
    var_dump($bar);
    echo "baz";
    var_dump($baz);
    echo "qux";
    var_dump($qux);
    echo "bar2";
    var_dump($bar2);
    echo "norf";
    var_dump($norf);

    // Clone: == true and === false
    echo '$bar == $bar2';
    var_dump($bar == $bar2); // true

    echo '$bar === $bar2';
    var_dump($bar === $bar2); // false

    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    echo '$bar === $baz';
    var_dump($bar === $baz); // false

    // Object reference: == true and === true
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    echo '$bar === $qux';
    var_dump($bar === $qux); // true

    // Two different objects: == false and === false
    echo '$bar == $norf';
    var_dump($bar == $norf); // false

    echo '$bar === $norf';
    var_dump($bar === $norf); // false

    // 2. Instances with matching attributes and its values (only ==).
    //    What happens when objects (even in cloned object) have same
    //    attributes but varying values?

    // $foobar value is different
    echo "2. Instances with matching attributes  and its values (only ==) <br />";

    $baz->foobar = 2;
    echo '$foobar' . " value is different <br />";
    echo '$bar->foobar = ' . $bar->foobar . "<br />";
    echo '$baz->foobar = ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false

    // $foobar's value is the same again
    $baz->foobar = 1;
    echo '$foobar' . " value is the same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    // Changing values of properties in $qux object will change the property
    // value of $bar and evaluates true always, because $qux = &$bar.
    $qux->foobar = 2;
    echo '$foobar value of both $qux and $bar is 2, because $qux = &$bar' . "<br />";
    echo '$qux->foobar is ' . $qux->foobar . "<br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    // 3. Instances with different attributes (only ==)
    //    What happens when objects have different attributes even though
    //    one of the attributes has same value?
    echo "3. Instances with different attributes (only ==) <br />";

    // Dynamically create a property with the name in $name and value
    // in $value for baz object
    $name = 'newproperty';
    $value = null;
    $baz->createNewProperty($name, $value);
    echo '$baz->newproperty is ' . $baz->{$name};
    var_dump($baz);

    $baz->foobar = 2;
    echo '$foobar' . " value is same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false
    var_dump($bar);
    var_dump($baz);
?>
1
Sathish

变量有一个类型和一个值。

  • $ var =“test”是一个包含“test”的字符串
  • $ var2 = 24是整数vhose值是24。

当您使用这些变量(在PHP中)时,有时您没有良好的类型。例如,如果你这样做

if ($var == 1) {... do something ...}

PHP必须将$ var转换为“整数”。在这种情况下,“$ var == 1”为true,因为任何非空字符串都会转换为1。

使用===时,检查值AND THE TYPE是否相等,因此“$ var === 1”为false。

这很有用,例如,当你有一个可以返回false(出错时)和0(结果)的函数时:

if(myFunction() == false) { ... error on myFunction ... }

这段代码错误,好像myFunction()返回0,它被转换为false,你似乎有一个错误。正确的代码是:

if(myFunction() === false) { ... error on myFunction ... }

因为测试是返回值“是布尔值并且是假的”而不是“可以转换为假”。

1
ofaurax

===运算符应该比较 exact content相等,而==运算符将比较语义相等。特别是它会将字符串强制转换为数字。

平等是一个广泛的主题。请参阅 维基百科关于平等的文章

1
kmkaplan

=====在PHP数组和对象之间有两点不同,我认为这里没有提到;两个具有不同键排序和对象的数组。

两个具有不同键排序的数组

如果您有一个带有键排序的数组和另一个具有不同键排序的数组,它们是完全不同的(即使用===)。如果您对数组进行键排序,并尝试将已排序的数组与原始数组进行比较,则可能会导致这种情况。

例如,考虑一个空数组。首先,我们尝试将一些新索引推送到数组而不进行任何特殊排序。一个很好的例子是一个字符串作为键的数组。现在深入一个例子:

// Define an array
$arr = [];

// Adding unsorted keys
$arr["I"] = "we";
$arr["you"] = "you";
$arr["he"] = "they";

现在,我们有一个not-sorted-keys数组(例如''他'来自'你')。考虑相同的数组,但我们按字母顺序对其键进行排序:

// Declare array
$alphabetArr = [];

// Adding alphabetical-sorted keys
$alphabetArr["I"] = "we";
$alphabetArr["he"] = "they";
$alphabetArr["you"] = "you";

提示 :您可以使用 ksort() function按键对数组进行排序。

现在你有另一个数组与第一个数组有不同的键排序。所以,我们要比较它们:

$arr == $alphabetArr; // true
$arr === $alphabetArr; // false

注意 :这可能很明显,但使用严格比较比较两个不同数组总是会产生false。但是,使用===可以使两个任意数组相等。

你会说:“这种差异可以忽略不计”。然后我说这是一个区别,应该考虑并可能随时发生。如上所述,对数组中的键进行排序就是一个很好的例子。

对象

请记住,两个不同的对象永远不会严格相等。这些例子有助于:

$stdClass1 = new stdClass();
$stdClass2 = new stdClass();
$clonedStdClass1 = clone $stdClass1;

// Comparing
$stdClass1 == $stdClass2; // true
$stdClass1 === $stdClass2; // false
$stdClass1 == $clonedStdClass1; // true
$stdClass1 === $clonedStdClass1; // false

注意 :将对象分配给另一个变量不会创建副本 - 而是创建对与该对象相同的内存位置的引用。 看这里

注意 :从PHP7开始,添加了 匿名类 。从结果来看,上述测试中new class {}new stdClass()之间没有区别。

0
MAChitgarha