PHP 같음(== 이중 같음)과 항등(=== 삼중 같음) 비교 연산자는 어떻게 다릅니까?
https://stackoverflow.com/questions/80646
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
차이점은 무엇 입니까? == 그리고 ===?
- 느슨하게는 정확히 어떻게됩니까?
==비교작업? - 엄격한 것은 정확히 어떻게 이루어 집니까?
===비교작업?
유용한 예는 무엇입니까?
해결책
차이점 == 그리고 ===
느슨하게의 차이점 == 등호 연산자와 엄격한 === 동일한 연산자는 수동:
비교 연산자
┌──────────┬───────────┬───────────────────────────────────────────────────────────┐ │ Example │ Name │ Result │ ├──────────┼───────────┼───────────────────────────────────────────────────────────┤ │$a == $b │ Equal │ TRUE if $a is equal to $b after type juggling. │ │$a === $b │ Identical │ TRUE if $a is equal to $b, and they are of the same type. │ └──────────┴───────────┴───────────────────────────────────────────────────────────┘
느슨하게 == 동등한 비교
당신이 사용하는 경우 == 연산자 또는 다음과 같이 느슨하게 비교를 사용하는 기타 비교 연산자 !=, <> 또는 ==, 항상 살펴봐야 합니다. 문맥 무슨 일이 일어나고 있는지 이해하기 위해 무엇을, 어디서, 왜 변환하는지 확인합니다.
규칙 변환
유형 비교표
참조 및 예로서 다음 비교표를 볼 수 있습니다. 수동:
느슨한 비교
==┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐ │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ array() │ "php" │ "" │ ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤ │ TRUE │ TRUE │ FALSE │ TRUE │ FALSE │ TRUE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ │ 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 │ 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 │ 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 │ FALSE │ TRUE │ FALSE │ 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 │ │ array() │ 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 │ └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
다른 팁
== 연산자는 서로 다른 두 유형 사이를 캐스팅하는 반면 === 연산자는 '유형 안전 비교'를 수행합니다.즉, 두 피연산자가 모두 동일한 유형과 동일한 값을 갖는 경우에만 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 이중 같음 == 평등 차트:
PHP 트리플 같음 === 평등 차트:
이러한 이미지를 생성하는 소스 코드:
https://github.com/sentientmachine/php_equality_charts
전문가 명상
제정신을 유지하고 싶은 사람들은 더 이상 읽지 마십시오. 왜냐하면 이것이 PHP의 광기 프랙탈이 설계된 방식이라는 점을 제외하고는 이 중 어느 것도 의미가 없기 때문입니다.
NAN != NAN하지만NAN == true.==왼쪽이 숫자인 경우 왼쪽 및 오른쪽 피연산자를 숫자로 변환합니다.그래서123 == "123foo", 하지만"123" != "123foo"따옴표로 묶인 16진수 문자열은 때때로 부동 소수점이며, 뜻하지 않게 부동으로 캐스팅되어 런타임 오류가 발생합니다.
==왜냐하면 전이적이지 않기 때문입니다."0"== 0, 그리고0 == ""하지만"0" != ""- 아직 선언되지 않은 PHP 변수는 false입니다. PHP에 정의되지 않은 변수를 나타내는 방법이 있더라도 해당 기능은 다음과 같이 비활성화됩니다.
==. "6" == " 6","4.2" == "4.20", 그리고"133" == "0133"하지만133 != 0133.하지만"0x10" == "16"그리고"1e3" == "1000"예상치 못한 문자열 변환을 8진수로 노출하면 귀하의 지시나 동의 없이 발생하여 런타임 오류가 발생합니다.False == 0,"",[]그리고"0".숫자가 충분히 크면 == 무한대입니다.
새로운 클래스는 == to 1입니다.
- False는 가장 위험한 값입니다. 왜냐하면 False는 대부분의 다른 변수에 대해 ==이며 대부분 목적을 무너뜨리기 때문입니다.
희망:
PHP를 사용하는 경우 이중 등호 연산자를 사용하지 마십시오. 삼중 등호를 사용하는 경우 걱정해야 할 유일한 예외 사례는 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 사실이 나옵니다.
=== 객체의 내부 객체 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 (거짓 - 값 && 유형이 동일하지 않음)
- 사실이다 부울
- 1은 정수
그것은 데이터 유형에 관한 것입니다.받아 BOOL (참 또는 거짓) 예를 들면 다음과 같습니다.
true 또한 같음 1 그리고false 또한 같음 0
그만큼 == 비교할 때 데이터 유형은 신경 쓰지 않습니다.따라서 변수가 1인 경우(또한 true):
$var=1;
그리고 다음과 비교해 보세요. ==:
if ($var == true)
{
echo"var is true";
}
하지만 $var 실제로는 같지 않다 true, 그렇지?int 값은 다음과 같습니다. 1 대신 이는 true와 동일합니다.
와 함께 ===, 데이터 유형을 검사하여 두 변수/객체/무엇이든 동일한 유형을 사용하고 있는지 확인합니다.
그래서 내가 그랬다면
if ($var === true)
{
echo "var is true";
}
그 조건은 사실이 아닐 것이다. $var !== true 그것뿐 == true (무슨 말인지 아시는 분 계시다면)
왜 이것이 필요할까요?
간단합니다. PHP의 기능 중 하나를 살펴보겠습니다. array_search():
그만큼 array_search() 함수는 단순히 배열에서 값을 검색하고 값이 발견된 요소의 키를 반환합니다.배열에서 값을 찾을 수 없으면 반환됩니다. 거짓.하지만 만약 당신이 그런 일을 했다면 어떨까요? 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){} //true
주어진 x = 5
1) 운영자 :==는 "같음"입니다. x == 8 거짓이다
2) 운영자 :===는 "정확히 같음"(값 및 유형)입니다. x === 5 사실이다, x === "5" 거짓이다
몇 가지 예
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.
추신
== 값만 비교하며 데이터 유형에 대해서는 신경 쓰지 않습니다.
대
=== 값과 데이터 유형을 비교합니다.
$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...
}
대
// 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() !==)을 권장하는 이유입니다. false)"를 사용하여 실수를 방지합니다.
===를 사용하면 단순히 false(0 또는 빈 문자열)와 동일시하는 대신 함수나 변수가 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는 테스트에서 false와 동일한 0을 반환합니다.
if ($pos == false)
또는
if (!$pos)
여기서는 당신이 원하는 것이 아닙니다.
어느 것을 다른 것 위에 사용해야 하는지에 대해서는 예를 들어 fwrite() PHP의 함수.
이 함수는 파일 스트림에 콘텐츠를 씁니다.PHP에 따르면, "fwrite() 쓴 바이트 수를 반환하거나 오류가 발생하면 FALSE를 반환합니다."함수 호출이 성공했는지 테스트하려는 경우 이 방법에는 결함이 있습니다.
if (!fwrite(stuff))
{
log('error!');
}
0을 반환할 수 있으며(성공한 것으로 간주됨) 조건이 계속 트리거됩니다.올바른 방법은 다음과 같습니다.
if (fwrite(stuff) === FALSE)
{
log('error!');
}
PHP는 느슨한 형식의 언어입니다.이중 등호 연산자를 사용하면 변수를 느슨하게 검사할 수 있습니다.
값을 느슨하게 확인하면 유사하지만 동일하지 않은 값이 동일한 것으로 간주될 수 있습니다.
- ''
- 없는
- 거짓
- 0
이러한 값은 모두 이중 같음 연산자를 사용하여 같음과 같습니다.
php ==는 변수의 값을 비교하는 비교 연산자입니다.그러나 ===는 값과 데이터 유형을 비교합니다.
예를 들어,
<?php
$var1 = 10;
$var2 = '10';
if($var1 == $var2) {
echo 'Variables are equal';
} else {
echo 'Variables are not equal';
}
?>
이 경우 데이터 유형이 다르더라도 출력은 '변수가 동일합니다'입니다.
그러나 == 대신 ===를 사용하면 '변수가 동일하지 않음'이 출력됩니다.PHP는 먼저 변수 값을 비교한 다음 데이터 유형을 비교합니다.여기서 값은 동일하지만 데이터 유형이 다릅니다.
변수에는 유형과 값이 있습니다.
- $var = "test"는 "test"를 포함하는 문자열입니다.
- $var2 = 24는 정수입니다. vhose 값은 24입니다.
PHP에서 이러한 변수를 사용할 때 때로는 좋은 유형이 아닐 때가 있습니다.예를 들어, 다음과 같이 하면
if ($var == 1) {... do something ...}
PHP는 $var를 정수로 변환("캐스트")해야 합니다.이 경우 비어 있지 않은 문자열이 1로 변환되므로 "$var == 1"은 true입니다.
===를 사용할 때 값과 유형이 동일한지 확인하므로 "$var === 1"은 false입니다.
이는 예를 들어 false(오류 시) 및 0(결과)을 반환할 수 있는 함수가 있는 경우에 유용합니다.
if(myFunction() == false) { ... error on myFunction ... }
이 코드는 잘못된 것 같습니다. myFunction() 0을 반환하면 false로 캐스팅되어 오류가 발생한 것 같습니다.올바른 코드는 다음과 같습니다
if(myFunction() === false) { ... error on myFunction ... }
테스트에서는 반환 값이 "부울이고 false"이고 "false로 변환될 수 없음"이 아니기 때문입니다.
그만큼 === 연산자는 비교해야합니다 정확한 콘텐츠 평등 == 연산자는 의미론적 동등성을 비교합니다.특히 문자열을 숫자로 강제 변환합니다.
평등은 광범위한 주제입니다.보다 평등에 관한 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);
?>
지금까지의 모든 답변은 ===의 위험한 문제를 무시했습니다.통과하면서 언급했지만 강조하지는 않았지만 정수와 이중은 서로 다른 유형이므로 다음 코드는 다음과 같습니다.
$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n == $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );
다음을 제공합니다:
equal
not equal
이는 "반올림 오류"의 경우가 아닙니다.두 숫자는 마지막 비트까지 정확히 동일하지만 유형이 다릅니다.
===를 사용하는 프로그램은 모든 숫자가 충분히 작을 경우("충분히 작다"는 것은 실행 중인 하드웨어 및 OS에 따라 다름) 수년 동안 문제 없이 실행될 수 있기 때문에 이것은 불쾌한 문제입니다.그러나 우연히 정수가 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";
이제 정렬되지 않은 키 배열이 생겼습니다(예: 'you' 뒤에 'he'가 옵니다).동일한 배열을 고려하지만 키를 알파벳순으로 정렬했습니다.
// 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() 위의 테스트에서.
