web-dev-qa-db-ja.com

PHP等価（==二重等価）と同一性（===三重等価）の比較演算子はどう違うのですか？

==と===の違いは何ですか？

  • ==の大まかな比較はどの程度正確に機能しますか？
  • 厳密な===比較はどの程度正確に機能しますか？

便利な例は何でしょうか。

phpcomparisonoperatorsequalityidentity-operator
469
nickf

==と===の違い

緩い==等号演算子と厳密な===同一演算子の違いは、 マニュアル で正確に説明されています。

比較演算子

───────────────────────────────────── ───────────────────────────────
│例│名前│結果│
├─────────────────────────────────────────── ─────────────────────────────────────│$ a == $ b│等しい│型ジャグリング後に$ aが$ bに等しい場合はTRUE。 │
│$ a === $ b│同一│$ aが$ bに等しく、それらが同じ型であればTRUE。 │
└─────────────────────────────────────────── ───────────────────────────────────────

==同値比較

==演算子、または!=、<>、==のような大まかな比較を使用する他の比較演算子を使用している場合は、必ずコンテキストを見て何を確認する必要があります。そして何が起こっているのか理解するために何かが変換されるのはなぜでしょう。

変換ルール

タイプ比較表

参考と例として、 マニュアル の比較表を見てください。

==とのゆるい比較

≪─────────────────────────────────────────── ┬─────────────────────────────────────────────── .────────
││TRUE│FALSE│1│0│-1│ "1"│「0」│「-1」│NULL│array（）│「php」│ ""│
├──────────────────────────────────────── ┼───────┼─────────────────────────────────── ┼───────────────┤
│TRUE│TRUE│FALSE│TRUE│FALSE│TRUE│FALSE│TRUE│FALSE│FALSE│TRUE│FALSE│
│FALSE│FALSE│TRUE│FALS E│TRUE│FALSE│FALSE│TRUE│FALSE│TRUE│FALSE│TRUE│
│1│TRUE│FALSE│TRUE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE FALSE│
│0│FALSE│TRUE│FALSE│TRUE│FALSE│TRUE│FALSE│TRUE│TRUE│
│-1│TRUE│FALSE│FALSE ││TRUE FALSE FALSE│││TRUE FALSE FALSE│││FALSE FALSE│
│ "1" ││TRUE FALSE TRUE│││FALSE FALSE TRUE│││FALSE FALSE FALSE│││FALSE FALSE FALSE│ │
│ "0"│FALSE│TRUE│FALSE│TRUE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│
│「-1」│TRUE│FALSE│ FALSE│FALSE│TRUE│FALSE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│
│NULL│FALSE│ TRUE│FALSE│TRUE│FALSE│FALSE│FALSE│TRUE│TRUE│FALSE│TRUE│
│array（）│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│ TRUE│FALSE│FALSE│
│ "php"│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│
│ ""│FALSE │TRUE│FALSE│TRUE│FALSE│FALSE│FALSE│TRUE│FALSE│FALSE│TRUE│
└────────────────────── ────────────────────────────────────────────────── ────────────────────────────────────

厳密な===同一比較

===演算子、または!==や===のような厳密な比較を使用する他の比較演算子を使用している場合は、必ず型がmagicallyにならないようにしてください。変換は行われないので変更します。厳密な比較では、値だけでなく型と値も同じである必要があります。

タイプ比較表

参考と例として、 マニュアル の比較表を見てください。

===との厳密な比較

≪─────────────────────────────────────────── ┬─────────────────────────────────────────────── .────────
││TRUE│FALSE│1│0│-1│ "1"│「0」│「-1」│NULL│array（）│「php」│ ""│
├──────────────────────────────────────── ┼───────┼─────────────────────────────────── ┼────────────────
│TRUE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│[] .____。]│FALSE│FALSE│TRUE│FALS E│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│[.____。│1│FALSE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FAL│FALSE│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│FAL│ FALSE│
│0│FALSE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│
 FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE ││FALSE FALSE FALSE│││FALSE FALSE FALSE││││FALSE TRUE 
│ "1" ││FALSE FALSE FALSE FALSE│││FALSE FALSE│││TRUE FALSE FALSE FALSE│││FALSE FALSE│ │
│ "0"│FALSE│FALSE│FALSE│FALSE│TRUE│FALSE│FALSE│FALSE│FALSE│FALSE│
│「-1」│FALSE│FALSE│ FALSE│FALSE│FALSE│FALSE│FALSE│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│
│ "。│" |│ "。│"。 │FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│FALSE│TRUE│
└──────────────────── ────────────────────────────────────────────────── ────────────────────────────────────
591
nickf

演算子==は、異なる場合は2つの異なる型の間でキャストしますが、===演算子は「型保証された比較」を実行します。つまり、両方のオペランドの型と値が同じ場合にのみ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

警告：同等のメンバーを持つ同じクラスの2つのインスタンスは、===演算子と一致しません。例：

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

絵は千語の価値があります。

PHPの二重等価==等式表：

enter image description here

PHPのトリプル等しい===等式表：

enter image description here

これらの画像を作成するためのソースコード：

https://github.com/sentientmachine/php_equality_charts

達人瞑想

これがPHPの狂気のフラクタルがどのように設計されたかであると言うことを除いて、これのどれもが意味をなさないので、彼らの正気を保ちたい人はこれ以上読んではいけない。

  1. NAN != NANしかしNAN == true。
  2. leftが数値の場合、==は左右のオペランドを数値に変換します。だから123 == "123foo"、しかし"123" != "123foo"

  3. 引用符で囲まれた16進文字列はときどきfloat型になり、あなたの意志に反してfloat型にキャストされてしまい、実行時エラーが発生します。

  4. ==は推移的ではありません。"0"== 0、および0 == ""は"0" != ""です

  5. PHPに未定義の変数を表す方法があるにもかかわらず、まだ宣言されていないPHP変数はfalseです。この機能は==で無効になっています。

  6. "6" == " 6"、"4.2" == "4.20"、および"133" == "0133"、ただし133 != 0133。しかし、"0x10" == "16"と"1e3" == "1000"は、予期せぬ文字列変換を8進数に変換すると、ユーザーの指示や同意なしに実行され、ランタイムエラーが発生する可能性があります。

  7. False == 0、""、[]、および"0"。

  8. 数が十分大きい場合、それらは== Infinityです。

  9. 新しいクラスは== to 1です。

  10. Falseは他のほとんどの変数に対して==であるため、Falseが最も危険な値です。

希望：

PHPを使用している場合は、二重等号演算子を使用しないでください。トリプル等号を使用する場合、心配しなければならないEdgeのケースはNANと無限大に近い数値だけなので、無限大にキャストされます。二重の等号では、何かが何かに驚いて==になることもあれば、あなたの意志に反して驚いてキャストすることもできますし、!=が明らかに等しいはずのものにキャストすることもできます。

どこにいてもPHPで==を使うのはひどいコードの匂いです。なぜなら、ブラウン運動を使ってプログラミングする何百万ものプログラマーによって設計されている暗黙のキャスト規則によって85個のバグが露呈されるためです。

68
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

オブジェクト比較に関する他の回答への追加：

==は、オブジェクトの名前とその値を使用してオブジェクトを比較します。 2つのオブジェクトが同じ型で同じメンバ値を持つ場合、$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

簡単に言えば、

==が等価かどうかをチェックします（値のみ）

===が同じか（値&&タイプ）


等価対同一：アナロジー

1 + 1 = 2 + 0（等価）

1 + 1 = 1 + 1（同じ）


PHPの場合：

true == 1（true - 等価な値）

true === 1（false - 値&&タイプが同じではありません）

  • trueはブール値
  • 1はintです
13
silver

それはすべてデータ型に関するものです。例えばBOOL（trueまたはfalse）を取ります。

trueも1と等しく、falseも0と等しくなります

==は、比較時にデータ型を気にしません。つまり、変数が1の場合（trueでも構いません）、

$var=1;

そして==と比較してください。

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

しかし$varは実際にはtrueと等しくありませんね。それは代わりに1のint値を持ち、それは今度はtrueに等しくなります。

===では、2つの変数/ objects /が同じ型を使用していることを確認するためにデータ型がチェックされます。

だから私がした場合

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

$var !== trueそれは== trueのみなので、その条件は真実ではないでしょう（あなたが私の意味を知っていれば）。

なぜあなたはこれが必要でしょうか？

簡単です - PHPの関数の1つを見てみましょう：array_search()：

array_search()関数は単純に配列内の値を検索し、その値が見つかった要素のキーを返します。その値が配列内に見つからなかった場合はfalseを返します。しかし、配列の最初の要素に格納されている値に対してarray_search()を実行した場合（0の配列キーを持つことになります）.... array_search()関数は0を返します。これはfalseに等しいです..

あなたがしたのであれば：

$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はfalseです
2）演算子：===は "正確に等しい"（値と型）x === 5は真、x === "5"は偽

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.

P.S.

==値のみを比較します。データ型については気にしません。

vs.

===値とデータ型を比較します

4
Mohit Tanwani

つまり、===は==が他のほとんどのプログラミング言語と同じように機能します。

PHPでは、あまり意味のない比較を行うことができます。例：

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

これはいくつかの興味深い "ショートカット"を可能にしますが、（数値の代わりに "エラー"のように）それが返すべきではないものを返す関数はキャッチされないので注意してください。

PHPでは、==は値を比較し、必要に応じて型変換を実行します（たとえば、整数比較では文字列 "12343sdfjskfjds"は "12343"になります）。 ===は値AND typeを比較し、型が同じでなければfalseを返します。

PHPマニュアルを見ると、関数が失敗すると多くの関数が "false"を返すことがわかりますが、成功したシナリオでは0が返される可能性があります。 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は最初に変数の値を比較し、次にデータ型を比較します。ここでは値は同じですが、データ型は異なります。

2
2rahulsk

答えはすべてこれまでのところ===で危険な問題を無視しています。これまでに述べたように、整数と倍精度浮動小数点は異なる型であることを強調しています。

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

を与えます：

 equal
 not equal

これは「丸め誤差」の場合ではないことに注意してください。 2つの数字は最後のビットまではまったく同じですが、タイプは異なります。

===を使うプログラムは、すべての数が十分に小さい場合（何を実行するハードウェアとOSに依存するかということで）何年もの間楽しく実行できるので、これは厄介な問題です。ただし、偶然に整数が倍精度に変換されるのに十分な大きさになった場合、後続の操作または多数の操作によって値が小さい整数に戻される可能性があるとしても、その型は「永久に」変更されます。そして、それは悪化します。それは広がる可能性があります - 二重感染は、一度に1回の計算で、それが触れているものすべてに渡すことができます。

現実の世界では、これはたとえば2038年以降の日付を扱うプログラムでは問題になる可能性があります。現時点では、UNIXのタイムスタンプ（1970-01-01 00:00:00 UTCからの経過秒数）は32ビット以上を必要とするため、一部のシステムではそれらの表現は「魔法のように」2倍に切り替わります。したがって、2回の差を計算すると、2、3秒で終わる可能性がありますが、2017年に発生する整数の結果ではなく、2倍になります。

微妙なので、これは文字列と数値の間の変換よりもはるかに悪いと思います。何が文字列で何が数値であるかを追跡するのは簡単ですが、数値内のビット数を追跡​​することは私を超えています。

したがって、上記の回答にはいくつかのNiceテーブルがありますが、1（整数として）と1（微妙な倍精度）と1.0（明らかな倍精度）の間に違いはありません。また、===が正しく動作する場所では===が失敗することがあるため、===を使用して========================== ====================== ======================== =============================================================================== ========================= ================= ==============--========--24-24ので不一致なので、うまくいかないためです。また、JavaScriptは数値型が1つしかないため、この点では同等ではありません（内部的にはビットごとの表現が異なりますが、===の問題は発生しません）。

私の忠告 - どちらも使わないでください。あなたは本当にこの混乱を修正するためにあなた自身の比較関数を書く必要があります。

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は整数です。値は24です。

（PHPで）これらの変数を使用すると、適切な型が得られないことがあります。たとえば、

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

PHPは$ varを整数に変換（ "キャスト"）する必要があります。この場合、空でない文字列は1にキャストされるため、 "$ var == 1"が真になります。

===を使用するときは、値とタイプが等しいことを確認します。したがって、 "$ var === 1"はfalseです。

たとえば、false（エラー時）と0（結果）を返すことができる関数がある場合に便利です。

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

このコードは、myFunction()が0を返した場合は間違っています。falseにキャストされた場合、エラーが発生したようです。正しいコードは次のとおりです。

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

なぜなら、戻り値は「ブール値であり、false」であり、「falseにキャストすることはできない」からです。

1
ofaurax

===演算子は完全な内容の等価性を比較し、==演算子は意味的な等価性を比較します。特に文字列を数値に変換します。

平等は大きな課題です。 平等に関するウィキペディアの記事 を参照してください。

1
kmkaplan

PHP配列とオブジェクトにおける==と===の間には2つの違いがあります。キーの種類が異なる2つの配列、およびオブジェクト。

キーの種類が異なる2つの配列

キーの種類を持つ配列とキーの種類が異なる別の配列がある場合、それらは厳密に異なります（つまり===を使用）。配列をキーソートして、ソートされた配列を元の配列と比較しようとすると、これが発生する可能性があります。

たとえば、空の配列を考えます。まず、特別な並べ替えなしでいくつかの新しいインデックスを配列にプッシュします。良い例は、キーとして文字列を持つ配列です。今すぐ例に深く：

// Define an array
$arr = [];

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

現在、ソートされていないキー配列があります（たとえば、「彼」は「あなた」の後に来ました）。同じ配列を考えますが、キーをアルファベット順にソートしました。

// Declare array
$alphabetArr = [];

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

ヒント： ksort（） 関数を使用して、キーで配列をソートできます。

これで、最初のものとは異なるキーの種類を持つ別の配列ができました。それで、我々はそれらを比較するつもりです：

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

注：明らかなことかもしれませんが、厳密な比較を使用して2つの異なる配列を比較すると、常にfalseになります。ただし、===を使用して任意の2つの配列が等しくなる場合もあれば、そうでない場合もあります。

「この違いはごくわずかです」と言うでしょう。それから私はそれが違いであり、考慮されるべきでありいつでも起こるかもしれないと言います。前述のように、配列内のキーのソートはその好例です。

オブジェクト

2つの異なるオブジェクトが厳密に等しいことはありません。これらの例は役立ちます：

$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