PHP 평등 (== double equals)과 항등 (=== triple equals) 비교 연산자는 어떻게 다릅니 까?
답변:
차이 사이 ==와===
느슨하게 ==동등한 연산자와 엄격한 ===동일한 연산자 의 차이점 은 매뉴얼에 정확하게 설명되어 있습니다 .
비교 연산자
┌───────────┬───────────┬─────────────────────────── ──────────────────────────────────┐ │ 예 │ 이름 │ 결과 │ ├───────────┼───────────┼─────────────────────────── ──────────────────────────────────┤ │ $ a == $ b │ 같음 │ 저글링 유형 후 $ a가 $ b와 같으면 참입니다. │ │ $ a === $ b │ 동일 │ $ a가 $ b와 같고 유형이 같으면 참. │ └───────────┴───────────┴─────────────────────────── ──────────────────────────────────┘
느슨하게 ==동일한 비교
당신이 사용하는 경우 ==운영자, 또는 느슨하게 비교를 사용하는 다른 비교 연산자를 같은 !=, <>또는 ==, 당신은 항상보고있는 상황 뭔가가 무슨 일이 일어나고 있는지 이해로 변환됩니다 왜, 무엇을 볼 수 있습니다.
규칙 변환
타입 비교표
참조 및 예제로 매뉴얼 에서 비교 테이블을 볼 수 있습니다 .
와의 느슨한 비교
==┌─────────┬┬──────┬┬──────┬───────┬───────┬──────── ┬───────┬───────┬───────┬───────┬─────────┬──────── ┬───────┐ │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1"│ "0"│ "-1"│ NULL │ array () │ "php"│ ""│ ├─────────┼┼──────┼┼──────┼───────┼───────┼──────── ┼───────┼───────┼───────┼───────┼─────────┼──────── ┼───────┤ │ 참 │ 참 │ 거짓 │ 참 │ 거짓 │ 참 │ 참 │ 거짓 │ 참 │ 거짓 │ 거짓 │ 참 │ 거짓 │ │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ TRUE │ FALSE │ TRUE │ │ 1 │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ 0 │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ TRUE │ TRUE │ │ -1 │ True │ FALSE │ 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 │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "-1"│ TRUE │ 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 │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ │ ""│ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ └─────────┴┴──────┴┴──────┴───────┴───────┴──────── ┴───────┴───────┴───────┴───────┴─────────┴──────── ┴───────┘
엄격한 ===동일한 비교
당신이 사용하는 경우 ===와 같은 엄격한 비교를 사용하는 운영자, 또는 다른 비교 연산자 !==또는 ===, 당신은 항상 확인 유형하지 않을 수 있습니다 마술 변경을, 어떤 변환에 가고 없을 것 때문이다. 따라서 엄격한 비교를 통해 유형과 값은 값뿐만 아니라 동일해야합니다.
타입 비교표
참조 및 예제로 매뉴얼 에서 비교 테이블을 볼 수 있습니다 .
다음과의 엄격한 비교
===┌─────────┬┬──────┬┬──────┬───────┬───────┬──────── ┬───────┬───────┬───────┬───────┬─────────┬──────── ┬───────┐ │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1"│ "0"│ "-1"│ NULL │ array () │ "php"│ ""│ ├─────────┼┼──────┼┼──────┼───────┼───────┼──────── ┼───────┼───────┼───────┼───────┼─────────┼──────── ┼───────┤ │ TRUE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ FALSE │ FALSE │ TRUE │ 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 │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "1"│ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "0"│ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "-1"│ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ │ NULL │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ │ array () │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ │ "php"│ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ │ ""│ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ └─────────┴┴──────┴┴──────┴───────┴───────┴──────── ┴───────┴───────┴───────┴───────┴─────────┴──────── ┴───────┘
true하거나 false. 캐스팅하기 쉽습니다. 그러나 다른 모든 값에는 실질적인 목적으로 거의 무제한 조합이 있습니다. 입니까 "five" == 5? array(0) == 0? array(0,0,0) == 0? 0.0000000000000000000000000000000000000000000000000001 == array()?
false자바 스크립트에서 다른 배열을 제공 하지만, true그 값이 같은 한 PHP를 위해 제공됩니다 .
"000" != "00" , "000" == null, "000" == false, "0x0" == false, array() == 0, false != null, array() != null, false == "0x0", false == "000". PHP, 그것은 반대 행동이다 : "000" == "00" , "000" != null, "000" != false, "0x0" != false, array() != 0, false == null, array() == null, false != "0x0", false != "000".
== 연산자는 서로 다른 두 유형이 다른 경우 캐스트하지만 === 연산자는 '유형 안전 비교'를 수행합니다. 즉, 두 피연산자가 동일한 유형과 동일한 값을 갖는 경우에만 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)그림은 천 단어의 가치가 있습니다.
PHP Double Equals ==평등 차트 :
PHP Triple Equals ===Equal 차트 :
이러한 이미지를 생성하는 소스 코드 :
https://github.com/sentientmachine/php_equality_charts
전문가 명상
정신 건강을 유지하고자하는 사람들은 PHP의 광기가 아닌 부분이 설계된 방식이라고 말하는 것 외에는 아무런 의미가 없기 때문에 더 이상 읽을 필요가 없습니다.
NAN != NAN하지만NAN == true.==left가 숫자 인 경우 왼쪽 및 오른쪽 피연산자를 숫자로 변환합니다. 그래서123 == "123foo"하지만,"123" != "123foo"따옴표로 묶은 16 진 문자열은 때로는 부동 소수점이며, 의지에 따라 부동으로 던져져 런타임 오류가 발생합니다.
==하지 이적 때문에"0"== 0, 그리고0 == ""있지만,"0" != ""- 아직 선언되지 않은 PHP 변수는 PHP에 정의되지 않은 변수를 나타내는 방법이 있지만이 기능은로 비활성화되어
==있습니다. "6" == " 6","4.2" == "4.20"그리고"133" == "0133"그러나133 != 0133. 그러나"0x10" == "16"및"1e3" == "1000"진수에 깜짝 문자열 변환을 노출시키는 런타임 오류가 발생, 사용자의 명령 또는 동의없이 모두 발생합니다.False == 0,"",[]와"0".숫자가 충분히 크면 == 무한대입니다.
새로운 클래스는 ==에서 1입니다.
- False는 대부분의 다른 변수에 대해 ==이기 때문에 False가 가장 위험한 값이며 대부분 목적을 무시합니다.
기대:
PHP를 사용하는 경우 double equals 연산자를 사용하지 않아야합니다. triple equals를 사용하는 경우 걱정해야 할 유일한 경우는 NAN과 숫자가 무한대에 가깝기 때문에 무한대로 캐스트되기 때문입니다. 더블 이퀄라이저를 사용하면 무엇이든 놀라게 ==할 수 있고 또는 의지와!= 분명히 동등한 무언가에 .
==PHP에서 사용하는 곳 은 브라운 모션으로 프로그래밍하는 수백만 명의 프로그래머가 설계 한 암시 적 캐스팅 규칙에 의해 노출 된 85 개의 버그로 인해 코드 냄새가 심합니다.
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');
}객체 비교에 관한 다른 답변에 추가 :
==는 객체의 이름과 값을 사용하여 객체를 비교합니다. 두 객체의 유형이 동일하고 구성원 값이 동일한 경우$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가장 간단한 용어로 :
== 동등한 지 확인 (값만)
=== 동일한 지 확인 (값 && 유형)
항목과 같은 항목을 확인합니다.
1 + 1 = 2 + 0 (상당)
1 + 1 = 1 + 1 (동일)
PHP에서 :
참 == 1 ( 값이 동일 함)
true === 1 (false-&& 유형에서 동일하지 않음)
- 사실은 부울
- 1은 정수입니다
데이터 유형에 관한 것입니다. 테이크 BOOL예를 들어 (true 또는 false)를 :
true또한 동일 1과
false도 같다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를 반환합니다 . 그러나 배열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)따라서 이와 같은 경우 ===대신 데이터 유형을 확인하도록 대신 사용하십시오 .
데이터베이스 속성이 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){} //truephp ==는 변수 값을 비교하는 비교 연산자입니다. 그러나 ===는 값과 데이터 유형을 비교합니다.
예를 들어
<?php
$var1 = 10;
$var2 = '10';
if($var1 == $var2) {
echo 'Variables are equal';
} else {
echo 'Variables are not equal';
}
?>이 경우 데이터 유형이 다르더라도 출력은 '변수가 동일합니다'.
그러나 == 대신 ===를 사용하면 출력은 '변수가 동일하지 않습니다'. PHP는 먼저 변수의 값과 데이터 유형을 비교합니다. 여기서 값은 동일하지만 데이터 유형이 다릅니다.
$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...
}즉, ===는 대부분의 다른 프로그래밍 언어에서와 마찬가지로 ==와 동일하게 작동합니다.
PHP를 사용하면 실제로 의미가없는 비교를 할 수 있습니다. 예:
$y = "wauv";
$x = false;
if ($x == $y)
...이것은 몇 가지 흥미로운 "단축키"를 허용하지만, 숫자 대신에 "오류"와 같이하지 말아야 할 것을 반환하는 함수는 잡히지 않기 때문에주의해야합니다.
PHP에서 ==는 값을 비교하고 필요한 경우 유형 변환을 수행합니다 (예를 들어, 문자열 "12343sdfjskfjds"는 정수 비교에서 "12343"이 됨). === 값과 유형을 비교하고 유형이 같지 않으면 false를 반환합니다.
PHP 매뉴얼을 보면, 함수가 실패하면 많은 함수가 "false"를 반환하지만 성공적인 시나리오에서는 0을 반환 할 수 있으므로 "if (function ()! == 실수를 피하기 위해).
몇 가지 예
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.
=== 값과 데이터 유형을 비교
===를 사용하여 함수 또는 변수가 단순히 거짓 (0 또는 빈 문자열)과 동일하지 않고 거짓인지 테스트합니다.
$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)그것은 당신이 원하는 것이 아닙니다.
언제 다른 것을 사용할 것인지에 대해서는 fwrite()PHP 의 함수 를 예로 들어 보자 .
이 함수는 내용을 파일 스트림에 씁니다. PHP에 따르면 " fwrite()쓰기 된 바이트 수를 반환하거나 오류가 발생하면 FALSE를 반환합니다." 함수 호출이 성공했는지 테스트하려는 경우이 메소드에 결함이 있습니다.
if (!fwrite(stuff))
{
log('error!');
}0을 리턴 할 수 있으며 (성공으로 간주 됨) 조건이 여전히 트리거됩니다. 올바른 방법은 다음과 같습니다.
if (fwrite(stuff) === FALSE)
{
log('error!');
}변수에는 유형과 값이 있습니다.
- $ var = "test"는 "test"를 포함하는 문자열입니다
- $ var2 = 24는 정수 vhose 값이 24입니다.
PHP에서 이러한 변수를 사용할 때 때로는 좋은 유형이 아닙니다. 예를 들어
if ($var == 1) {... do something ...}PHP는 $ var을 정수로 변환해야합니다. 이 경우, 비어 있지 않은 문자열이 1로 캐스트되기 때문에 "$ var == 1"은 true입니다.
===를 사용할 때 AND AND TYPE 값이 동일한 지 확인하여 "$ var === 1"이 false입니다.
예를 들어 false (오류시) 및 0 (결과)을 반환 할 수있는 함수가있는 경우에 유용합니다.
if(myFunction() == false) { ... error on myFunction ... }이 코드는 myFunction()0을 반환 하는 것처럼 잘못되어 false로 캐스팅되고 오류가있는 것 같습니다. 올바른 코드는 다음과 같습니다
if(myFunction() === false) { ... error on myFunction ... }테스트는 리턴 값이 "부울이고 거짓"이고 "거짓으로 캐스트 될 수 없음"이기 때문입니다.
===연산자는 정확한 내용 평등 을 비교해야 하지만 연산자는 ==의미 평등 을 비교해야합니다 . 특히 문자열을 숫자로 강제 변환합니다.
평등은 방대한 주제입니다. 평등에 관한 Wikipedia 기사를 참조하십시오 .
<?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);
?>지금까지의 모든 대답은 ===의 위험한 문제를 무시합니다. 정수와 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 년에 발생하는 정수 결과가 아니라 몇 초가 걸리지 만 두 배가 될 수 있습니다.
나는 이것이 미묘하기 때문에 문자열과 숫자 사이의 변환보다 훨씬 나쁘다고 생각합니다. 문자열과 숫자가 무엇인지 추적하는 것이 쉽지만 숫자의 비트 수를 추적하는 것은 저쪽에 있습니다.
따라서 위의 답변에는 멋진 테이블이 있지만 1 (정수)과 1 (미묘한 이중)과 1.0 (명백한 이중) 사이에는 차이가 없습니다. 또한 ==가 제대로 작동하는 경우 ===가 실패하기 때문에 항상 ===를 사용하고 절대 ==를 사용하지 않아야한다는 조언이 있습니다. 또한 JavaScript는 하나의 숫자 유형 만 있기 때문에 이와 관련하여 동일하지 않습니다 (내부적으로 비트 단위 표현이 다를 수 있지만 ===에 대해서는 문제를 일으키지 않습니다).
내 충고-둘 다 사용하지 마십시오. 이 혼란을 실제로 해결하려면 자체 비교 함수를 작성해야합니다.
==와 사이에는 두 가지 차이점이 있습니다=== PHP 배열과 내가 여기에 언급하지 않았다 생각 객체에서이; 키 정렬이 다른 두 개의 배열과 객체.
키 정렬이 다른 두 개의 배열
키 정렬이있는 배열과 다른 키 정렬이있는 다른 배열이있는 경우 엄격하게 다릅니다 (예 : 사용 ===). 배열을 키 정렬하고 정렬 된 배열을 원래 배열과 비교하려고하면 발생할 수 있습니다.
예를 들어 빈 배열을 고려하십시오. 먼저, 특별한 정렬없이 새로운 인덱스를 배열에 추가하려고합니다. 문자열을 키로 사용하는 배열이 좋은 예입니다. 이제 예를 들어 보자.
// 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참고 : 분명 할 수 있지만 엄격한 비교를 사용 하여 두 개의 서로 다른 배열을 비교하면 항상 결과가 나타납니다 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()테스트의 차이는 없습니다 .