Как различаются операторы сравнения равенства (==) и идентичности (===) в PHP?

Оператор == осуществляет неявное преобразование типов для двух различных типов, если они отличаются, тогда как оператор === выполняет "сравнение с учётом типов". Это означает, что он вернёт true, только если оба операнда имеют одинаковый тип и одинаковое значение.

Примеры:

1 === 1: true
1 == 1: true
1 === "1": false // 1 - это целое число, "1" - строка
1 == "1": true // "1" преобразуется в целое число, что равно 1
"foo" === "foo": true // оба операнда - строки и имеют одно и то же значение

Предупреждение: два экземпляра одного и того же класса с эквивалентными членами не совпадут при использовании оператора ===. Пример:

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

Таким образом, важно помнить, что оператор === проверяет не только значение, но и тип, и что даже "похожие" объекты не будут считаться равными.

Оператор === в JavaScript работает аналогично оператору ==, но требует, чтобы операнды не только имели одинаковое значение, но и один и тот же тип данных.

В приведенном примере сработает условие, проверяющее равенство (x == y), и отобразится сообщение 'x and y are equal', но условие на строгое равенство (x === y) не сработает, и сообщение 'x and y are identical' не появится.

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.

Оператор === сравнивает внутренний идентификатор объектов. Даже если свойства равны, выражение $a !== $b вернет true, если это не один и тот же объект.

Пример кода:

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;  // true
$a1 == $a2;  // true, свойства одинаковы
$a1 != $b;   // true, разные классы

$a1 === $a1; // true
$a1 !== $a2; // true, это не один и тот же объект

Таким образом, важно понимать различия между двумя операторами сравнения и в каких случаях каждый из них следует использовать.

Всё дело в типах данных. Например, рассмотрим тип BOOL (истина или ложь):

true также равен 1, а false равен 0.

Оператор == не учитывает типы данных при сравнении. Таким образом, если у вас есть переменная, равная 1 (которая также может считаться true):

$var = 1;

и вы сравните её с true:

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

Но на самом деле $var не равен true, верно? У него есть целочисленное значение 1, которое, в свою очередь, эквивалентно 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) {
    // Это вернет 0 (ключ элемента, в котором значение было найдено),
    // но поскольку мы используем ==, мы подумаем, что функция
    // на самом деле вернула false... хотя это не так.
}

Вам понятно, как это может быть проблемой?

Большинство людей не используют == false, когда проверяют, возвращает ли функция false. Вместо этого они используют !. Но на самом деле это то же самое, что и использовать == false, так что если вы сделаете:

$arr = array("name");
if (!array_search("name", $arr)) // Это то же самое, что делать (array_search("name", $arr) == false)

Таким образом, для подобных случаев лучше использовать ===, чтобы тип данных был проверен.

Для проверки того, является ли результат выполнения функции или переменной именно false, а не нулем или пустой строкой, следует использовать оператор ===. Это важно, так как strpos может вернуть 0, что в контексте условия будет интерпретироваться как false, если использовать обычное сравнение.

Вот пример кода на PHP:

$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
    echo $needle . ' не был найден в ' . $haystack;
} else {
    echo $needle . ' был найден в ' . $haystack . ' на позиции ' . $pos;
}

В данном случае использование оператора === позволяет корректно обработать ситуацию, так как strpos вернет 0, если символ найден в начале строки. Если бы мы использовали условие с обычным равенством, например:

if ($pos == false)

или

if (!$pos)

то это приведет к неправильному результату, так как 0 будет оценено как false, и мы erroneously скажем, что символ не найден, хотя на самом деле он находится в строке.