[SOLVED] The 3 different equals

What is the difference between `=`, `==`, and `===`?

I think using one equal sign is to declare a variable while two equal signs are for a comparison condition and lastly three equal signs are for comparing values of declared variables.

@Gideon 2019-02-25 13:12:25

The = operator assigns the value to a variable \$six = 6; value 6 is assigned to variable \$six

== operator check if the value of both variables is equal and mostly used in conditions like if statements

``````\$a = 2;
\$b = 2;
if (\$a == \$b) {
echo both variables have the same value;
}
``````

=== operator similar to == (check if the value equals) and also check if both of same data type

``````\$a = 2;
\$b = "2";
if (\$a === \$b) {
echo "both variable have same value and of same data type";
} else {
echo 'both variable is either not equal or not of same data type';
}
``````

// here \$a is of type int whereas \$b is of type string. So here the output

@gnarf 2010-01-14 10:43:18

You have `=` the assignment operator, `==` the 'equal' comparison operator and `===` the 'identical' comparison operator.

``````\$a = \$b     Assign      Sets \$a to be equal to \$b.
\$a == \$b    Equal       TRUE if \$a is equal to \$b.
\$a === \$b   Identical   TRUE if \$a is equal to \$b, and they are of the same type. (introduced in PHP 4)
``````

For more info on the need for `==` and `===`, and situations to use each, look at the docs.

@stloc 2016-01-08 09:20:50

when I compare two identical datetime, I have false result, why ? example : sandbox.onlinephpfunctions.com/code/…

@Andrea 2016-01-27 20:22:13

@stloc, `===` with objects tells you if they are the same object, not if they have the same content.

@Mvorisek 2018-07-13 15:36:32

Introduced in PHP4, funny in Y2018 ;-)

@lucaferrario 2013-07-08 14:03:07

For advanced PHP users, knowing the difference between `==`and `===` and asking themselves "is it faster to compare with `==` or with `===` when I'm sure that both the operands are the same type?"

The short and general answer is: There is no performance gain in using `===` in this cases, so you should probably use `==`.

For the ones interested in benchmarking it themselves, you can use the following code I wrote ad-hoc and try different values for `\$a` and `\$b`:

``````<?php
// CONFIGURATION
\$cycles = 1000000;
\$a = 'random string 1';
\$b = 'random string 2';

// FUNCTIONS
function compare_two_equals(\$a, \$b) {
if (\$a == \$b) {
return TRUE;
} else {
return FALSE;
}
}

function compare_three_equals(\$a, \$b) {
if (\$a === \$b) {
return TRUE;
} else {
return FALSE;
}
}

// EXECUTION
\$time = microtime(TRUE);
for (\$count_a = 0; \$count_a < \$cycles; \$count_a++) {
compare_two_equals(\$a, \$b);
}
\$time_two_a = microtime(TRUE) - \$time;
\$time = microtime(TRUE);
for (\$count_a = 0; \$count_a < \$cycles; \$count_a++) {
compare_three_equals(\$a, \$b);
}
\$time_three_a = microtime(TRUE) - \$time;
\$time = microtime(TRUE);
for (\$count_a = 0; \$count_a < \$cycles; \$count_a++) {
compare_two_equals(\$a, \$b);
}
\$time_two_b = microtime(TRUE) - \$time;
\$time = microtime(TRUE);
for (\$count_a = 0; \$count_a < \$cycles; \$count_a++) {
compare_three_equals(\$a, \$b);
}
\$time_three_b = microtime(TRUE) - \$time;
\$time = microtime(TRUE);

// RESULTS PRINTING
print "<br />\nCOMPARE == (FIRST TRY): " . number_format(\$time_two_a, 3) . " seconds";
print "<br />\nCOMPARE == (SECOND TRY): " . number_format(\$time_two_b, 3) . " seconds";
print "<br />\nCOMPARE === (FIRST TRY): " . number_format(\$time_three_a, 3) . " seconds";
print "<br />\nCOMPARE === (SECOND TRY): " . number_format(\$time_three_b, 3) . " seconds";
?>
``````

NOTE: The comparison is valid only when each "FIRST TRY" is very close to its "SECOND TRY". If they are significantly different, it means that the processor was busy doing something else while executing the comparisons and so the results are unreliable and the benchmark should be run again.

@gnarf 2013-11-12 05:00:05

Microbenchmarks like this are not very reliable. It is also highly unlikely that you'd ever want to worry about `==` or `===` as the cause of your performance problem. IMO: It's better to be strict (`===`) unless you explicitly want to be loose (`==`) about your comparisons. The number of strange edge cases i.e. `"5 is not a number" == 5` can lead to wacky bugs. `===` never suffers from this problem.

@lucaferrario 2016-02-18 15:40:05

My test was to tell programmers that if they're choosing `===` for performance reasons, they're wrong. So programmers are free to choose `===` or `==` based on logical reasons but not on performance reasons: there are different cases to prefer the one or the other and performance must not be taken into account at all.

• `=` is the assignment operator
• `==` is the comparison operator (checks if two variables have equal values)
• `===` is the identical comparison operator (checks if two variables have equal values and are of the same type).

@Silvio Donnini 2010-01-14 10:44:42

= assignment operator

== checks if two variables have the same value

=== checks if two variables have the same value AND if their types are the same

@Phil Perry 2013-08-21 16:57:19

Also know about != and !== 'not' versions of the two comparison operators. Some languages use := as assignment, just to avoid this kind of confusion.

[SOLVED] What are the differences in die() and exit() in PHP?

• 2009-11-25 06:28:07
• coderex
• 241918 View
• 641 Score
• Tags:   php exit die