it-swarm-ko.tech

PHP 동등성 (== double equals)과 identity (=== triple equals) 비교 연산자는 어떻게 다른가요?

=====의 차이점은 무엇입니까?

  • 얼마나 느슨하게 == 비교 작업을합니까?
  • 엄격한 === 비교 작업은 정확히 어떻게 작동합니까?

유용한 예는 무엇입니까?

469
nickf

=====의 차이점

느슨하게 == 등호 연산자와 엄격한 === 동일한 연산자의 차이점은 설명서 에 설명되어 있습니다.

비교 연산자

 ┌──────────┬───────────┬───────────────────── ├ 예 
 │ 예 │ 이름 │ 결과 │ 
 ├──────────────────────────────────────────────────────────────────────────────────────────────── ────────────────────────────────────────────────────────────────────────────────────────────────────────┤ $ b │ Equal │ 유형이 저글링 된 후 $ a가 $ b와 같으면 TRUE입니다. │ 
 │ $ a === $ b │ 동일 │ $ a가 $ b와 같고 둘 다 같은 유형이면 TRUE입니다. │ 
 └───────────────────────────────────────────────────────────────────────────────────────────────── ───────────────────────────────────────┘ 

느슨하게 == 동일 비교

당신이 == 운영자, 또는 !=, <> 또는 ==으로 느슨하게 비교를 사용하는 다른 비교 연산자를 사용하는 경우, 당신은 항상 컨텍스트 , 어디에서 무엇을 볼 수 봐야 무슨 일이 일어나고 있는지를 이해하기 위해 무언가가 개심하는 이유.

규칙 변환

유형 비교표

참조 및 예로서 매뉴얼 의 비교 테이블을 볼 수 있습니다 :

==와의 느슨한 비교

─────────────────────────────────────────────────────────────────────────────────────────────────────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ 
 │ │ │ TRUE FALSE 1 │ │ │ 0 -1 "1"│ "0"│ "-1"NULL │ │ 어레이 () │ 'PHP'│ │ ""│ 
 ├───────────────────────────────────────────────────────────────────────────────────────────── ┼───────┼───────┼───────┼───────┼───────┼───────── ┼───────┼───────┤ 
 │ │ TRUE TRUE FALSE │ │ │ TRUE TRUE FALSE │ │ │ TRUE TRUE FALSE │ │ │ FALSE FALSE FALSE │ │ │ TRUE 
 │ 거짓 │ 거짓 │ 참 │ 거짓 E │ │ TRUE FALSE FALSE │ │ │ TRUE TRUE FALSE │ │ │ TRUE TRUE FALSE │ │ 
 │ │ 1 TRUE FALSE │ │ │ TRUE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ FALSE │ 
 │ 0 │ │ TRUE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ TRUE TRUE FALSE │ │ │ FALSE TRUE TRUE │ │ 
 -1 │ │ │ TRUE FALSE FALSE FALSE │ │ TRUE FALSE │ │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ 
 │ "1"│ │ TRUE TRUE FALSE │ │ │ FALSE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ 
 │ "0"│ │ TRUE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ 
 │ "-1"FALSE │ │ │ TRUE [. .____] FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE NULL │ │ │ │ TRUE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE TRUE │ │ │ TRUE TRUE FALSE │ │ 
 │ 어레이 () │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE TRUE │ │ FALSE FALSE │ │ │ 
 │ 'PHP'
 │ │ TRUE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ ""│ TRUE FALSE TRUE FALSE │ │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ TRUE FALSE TRUE │ │ 
 └─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘ 

엄격한 === 동일 비교

당신은 그런 === 또는 !==로 엄격한 비교를 사용하는 === 운영자 또는 다른 비교 연산자를 사용하는 경우, 당신은 항상 확신 할 수있는 유형하지 않습니다 마술 변화 때문에이 전환이 일어나지 않을 것입니다. 엄격한 비교를 통해 유형과 값은 값뿐만 아니라 동일해야합니다.

유형 비교표

참조 및 예로서 매뉴얼 의 비교 테이블을 볼 수 있습니다 :

===와 엄격한 비교

┌─────────┬───────┬───────┬───────┬───────┬─────── ───────────────────────────────────────────────────────────────────────────────────────────────────── │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1"│ "0"│ "-1"│ NULL │ 배열 (│ │ "php"│) ──────────────────────────────────────────────────────────────────────────────── ""│ 
 ├───────────────────────────────────────────────────────────────────────────────────────────── ‥────────────────────────────────────────────────────────────────────────────────────────────────── ┼───────┼───────┤ 
 │ │ TRUE TRUE FALSE │ │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ FALSE 
 │ │ FALSE FALSE TRUE │ │ FALS E │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ 
 │ 0 │ │ FALSE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ 
 -1 │ │ │ FALSE FALSE FALSE │ │ FALSE FALSE TRUE FALSE │ │ │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ 
 │ "1"│ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ 
 │ "0"│ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ 
 │ "-1"FALSE │ │ │ FALSE 거짓 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ 참 │ 거짓 │ 거짓 │ 거짓 │ 거짓 │ [______] │ NULL │ 거짓 │ FALSE | FALSE | FALSE | FALSE | FALSE | FALSE | FALSE | FALSE | FALSE | FALSE FALSE │ │ │ 
 │ 'PHP'
 │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ TRUE FALSE FALSE │ │ │ ""│ TRUE FALSE FALSE FALSE │ │ │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE FALSE │ │ │ FALSE FALSE TRUE │ │ 
 └─────────┴───────┴─── ───────────────────────────────────────────────────────────────────────────────────────────────── ──┴───────┴─────────┴───────┴───────┘ 
591
nickf

== 연산자는 'typesafe comparison'을 수행하는 반면, 연산자는 == 연산자가 다르면 두 개의 다른 유형간에 변환을 수행합니다. 즉, 두 피연산자가 같은 유형 및 동일한 값을 갖는 경우에만 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 트리플이 같음 === 등호 차트 :

enter image description here

이러한 이미지를 생성하는 소스 코드 :

https://github.com/sentientmachine/php_equality_charts

전문가 명상

그들의 정신을 지키려는 사람들은 더 이상 읽을 수 없습니다. 왜냐하면 이것은 PHP의 광기 - 프랙탈이 어떻게 설계되었는지를 말하는 것 외에는 아무런 의미가 없기 때문입니다.

  1. NAN != NAN하지만 NAN == true.
  2. ==는 왼쪽 숫자가 숫자 인 경우 왼쪽 및 오른쪽 피연산자를 숫자로 변환합니다. 그래서 123 == "123foo"하지만 "123" != "123foo"
  3. 따옴표로 묶인 16 진수 문자열은 때로는 부동 소수점이며, 사용자의 의지와는 반대로 깜짝 캐스트되어 런타임 오류가 발생합니다.

  4. =="0"== 00 == ""이지만 "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. 숫자가 충분히 크면 == 무한대입니다.

  9. 새로운 클래스는 == 1입니다.

  10. False는 대부분의 다른 변수들에 대해 대부분의 위험한 값을 가지기 때문에 False는 가장 위험한 값이며 대부분이 False를 목적으로합니다.

기대:

PHP를 사용하는 경우, 트리플 등호를 사용하는 경우 걱정할 Edge 케이스는 NAN과 무한대에 가까운 숫자이므로 무한대로 캐스트되므로 Double equals 연산자를 사용하지 마십시오. 이중 같음을 사용하면 무엇이든 놀랄만한 ==을 할 수 있습니다. 또는 의지와 !=에 명백하게 동등한 것이어야합니다.

PHP에서 ==를 사용하는 곳은 갈색 모션으로 프로그래밍하는 수백만 프로그래머가 설계 한 암시 적 캐스팅 규칙에 의해 노출 된 85 개의 버그로 인해 나쁜 코드 냄새가납니다.

68
Eric Leschinski

자바 스크립트와 관련하여 :

=== 연산자는 == 연산자와 동일하게 작동하지만 피연산자의 값이 같을뿐만 아니라 동일한 데이터 유형도 필요합니다.

예를 들어, 아래의 샘플은 '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

가장 간단한 용어로 :

== =equivalent(값만)

===동일(값 && 유형)


동등한 대 동일 : 유추

1 + 1 = 2 + 0 (equivalent)

1 + 1 = 1 + 1 (동일)


PHP에서 :

true == 1 (true - 값이 동일)

true === 1 (false - 값이 && type과 같지 않음)

  • 사실입니다 부울
  • 1은 int
13
silver

데이터 유형이 전부입니다. BOOL (true 또는 false) 예를 들면 다음과 같습니다.

true1와 같으며 false0와 같습니다.

==는 비교할 때 데이터 유형을 신경 쓰지 않습니다. 따라서 변수가 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"이 거짓입니다

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

이 모든 값은 double equal 연산자를 사용하여 동일하게 간주됩니다.

2
Cory Collier

===를 사용하여 함수 또는 변수가 false (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는 테스트에서 false와 같을 0을 반환합니다.

if ($pos == false)

또는

if (!$pos)

너가 여기서 원하는게 아니야.

2
Stacey Richards

하나를 다른 것 이상으로 사용할 때는 PHP에서 예를 들어 fwrite() 함수를 사용하십시오.

이 함수는 내용을 파일 스트림에 씁니다. PHP에 따르면 "fwrite()은 쓴 바이트 수를 반환하고 오류가 있으면 거짓을 반환합니다." 함수 호출이 성공했는지 테스트하려면이 메서드에 결함이 있습니다.

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

0을 반환 할 수 있으며 성공한 것으로 간주되며 조건이 계속 트리거됩니다. 올바른 방법은 다음과 같습니다.

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

지금까지 모든 답변은 위험한 문제를 무시했습니다. 전달할 때 강조하지만 강조되지 않은 정수와 double은 다른 유형이므로 다음 코드를 참고하십시오.

$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 (명백한 이중) 간의 구분이 없습니다. 또한 === 및 never ==를 항상 사용해야한다는 조언은 좋지 않습니다. 왜냐하면 ==가 제대로 작동하는 곳에서 === 가끔 실패하기 때문입니다. 또한 자바 스크립트는 숫자 형식이 하나 밖에 없기 때문에 이와 동등하지 않습니다 (내부적으로 비트 단위 표현이 다를 수 있지만 ===에 문제가 발생하지는 않습니다).

나의 충고 - 사용하지 마라. 이 혼란을 실제로 수정하려면 자체 비교 함수를 작성해야합니다.

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를 정수로 변환해야합니다. 이 경우, "$ var == 1"은 비어 있지 않은 문자열이 1로 형 변환되기 때문에 참입니다.

===를 사용할 때, AND와 TYPE이 같은지 확인하므로 "$ var === 1"은 거짓입니다.

예를 들어 false (오류시)와 0 (result)을 반환 할 수있는 함수가있는 경우 유용합니다.

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

이 코드는 myFunction()이 0을 반환하고, false로 캐스팅되어 오류가있는 것처럼 잘못되었습니다. 올바른 코드는 다음과 같습니다.

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

테스트는 반환 값이 "부울이며 false"이며 "false로 캐스팅 될 수 없습니다"때문입니다.

1
ofaurax

=== 연산자는 정확한 내용 평등을 비교하는 반면 == 연산자는 의미 평등을 비교합니다. 특히 문자열을 숫자로 강제 변환합니다.

평등은 광대 한 주제입니다. 참조 평등에 관한 위키 피 디아 문서 .

1
kmkaplan

PHP 배열과 여기에 언급되지 않은 객체의 =====에는 두 가지 차이점이 있습니다. 다른 키 정렬을 가진 두 개의 배열 및 객체.

다른 키 정렬을 사용하는 두 개의 배열

키 정렬을 사용하는 배열과 다른 키 정렬을 사용하는 배열이있는 경우에는 완전히 다릅니다 (예 : === 사용). 배열을 키순으로 정렬하고 정렬 된 배열을 원래 배열과 비교하려고하면 그 결과가 발생할 수 있습니다.

예를 들어, 빈 배열을 고려하십시오. 먼저 특별한 정렬없이 새로운 인덱스를 배열에 푸시하려고합니다. 좋은 예는 문자열을 키로 사용하는 배열입니다. 이제 예제를 들어 보자.

// Define an array
$arr = [];

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

이제 정렬되지 않은 키 배열이 있습니다 (예 : 'he'는 'you'다음에 왔습니다.). 동일한 배열을 고려해 보았으나 알파벳 순으로 정렬했습니다.

// 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() 사이에는 차이가 없습니다.

0
MAChitgarha