Чем отличаются операторы сравнения PHP (== double equals) и тождества (=== triple equals)?

Question

Чем отличаются операторы сравнения PHP (== double equals) и тождества (=== triple equals)?

В чем разница между == а также ===?

Как именно работает слабо == Сравнительная работа?
Как именно строгий === Сравнительная работа?

Какие были бы полезные примеры?

577

php comparison operators equality identity-operator

Источник

user9021 17 сен '08 в 06:56

23 ответа

Решение

Оператор == осуществляет приведение между двумя различными типами, если они различаются, а оператор === выполняет "безопасное сравнение типов". Это означает, что он вернет 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)

252

Источник

user66760 26 фев '09 в 07:52

Одна картинка стоит тысячи слов:

PHP Двойные Равные `==` диаграмма равенства:

PHP Тройные Равные `===` Диаграмма равенства:

Исходный код для создания этих изображений:

https://github.com/sentientmachine/php_equality_charts

Медитация Гуру

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

'==' преобразует левый и правый операнды в числа, когда это возможно (123 == "123foo", но "123"!= "123foo"
Шестнадцатеричная строка в кавычках иногда является плавающей точкой и будет приведена к ней против вашей воли.
== не является транзитивным, потому что ("0" == к 0, а 0 = == к "", но "0"! = "")
"6" == "6", "4.2" == "4.20" и "133" == "0133". Но 133!= 0133, потому что 0133 восьмеричное. Но "0x10" == "16" и "1e3" == "1000"
Переменные PHP, которые еще не были объявлены, являются ложными.
False равно 0, пустой строке и пустому массиву и "0".
Когда числа достаточно велики, они == Бесконечность.
NAN не == сам, но это правда.
Свежий класс == до 1.
Ложь является наиболее опасным значением, потому что Ложь == для большинства других переменных, в основном, в ущерб ее цели.

Надежда:

Если вы используете PHP, не используйте оператор двойного равенства, всегда используйте тройное равенство.

121

Источник

user445131 03 ноя '16 в 00:42

Что касается 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');
}

38

Источник

17 сен '08 в 07:27

Дополнение к другим ответам относительно сравнения объектов:

== сравнивает объекты, используя имя объекта и его значения. Если два объекта одного типа и имеют одинаковые значения элементов, $a == $b дает истину.

=== сравнивает внутренний идентификатор объекта из объектов. Даже если члены равны, $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

23

Источник

user44562 26 фев '09 в 09:12

Проще говоря:

== проверяет эквивалентность (только значение)

=== проверяет, совпадает ли (значение && type)

Эквивалент против того же: аналогия

1 + 1 = 2 + 0 (эквивалент)

1 + 1 = 1 + 1 (тоже самое)

В PHP:

true == 1 (true - эквивалент по значению)

true === 1 (false - не совпадает по значению && type)

истина булева
1 является целым

12

Источник

user2806819 19 фев '15 в 09:52

Это все о типах данных. Возьмите BOOL (true или false), например:

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

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

$var=1;

А потом сравнить с ==:

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

Но $var на самом деле не равно true, Является ли? Имеет значение int 1 вместо этого, что, в свою очередь, равно истинному.

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

Так что если бы я сделал

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так что если вы сделали:

$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)

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

9

Источник

18 июл '12 в 16:08

Одним из примеров является то, что атрибут базы данных может быть нулевым или "":

$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

Источник

user1846814 14 окт '15 в 13:09

Дано x = 5

1) Оператор: == "равно". x == 8 ложно
2) Оператор: === "точно равен" (значение и тип) x === 5 правда, x === "5" ложно

6

Источник

user151523 17 авг '09 в 12:33

Двойное равенство PHP `==` :

В большинстве языков программирования оператор сравнения (==) проверяет, с одной стороны, тип данных, а с другой - содержимое переменной на равенство. Стандартный оператор сравнения (==) в PHP ведет себя иначе. Он пытается преобразовать обе переменные в один и тот же тип данных перед сравнением и только после этого проверяет, одинаково ли содержимое этих переменных. Получены следующие результаты:

      <?php
    var_dump( 1 == 1 );     // true
    var_dump( 1 == '1' );   // true
    var_dump( 1 == 2 );     // false
    var_dump( 1 == '2' );   // false
    var_dump( 1 == true );  // true
    var_dump( 1 == false ); // false
?>

PHP Triple Equals `===` :

Этот оператор также проверяет тип данных переменной и возвращает (bool) true, только если обе переменные имеют одинаковое содержимое и один и тот же тип данных. Таким образом, будет правильным следующее:

      <?php
    var_dump( 1 === 1 );     // true
    var_dump( 1 === '1' );   // false
    var_dump( 1 === 2 );     // false
    var_dump( 1 === '2' );   // false
    var_dump( 1 === true );  // false
    var_dump( 1 === false ); // false
?>

Подробнее читайте в В чем разница между == и === в PHP

4

Источник

user12903396 09 янв '21 в 19:03

Немного примеров

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.

PS

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

против

=== Сравнивает значения и типы данных

4

Источник

user6608101 26 авг '16 в 15:48

$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...
}

3

Источник

user2427672 01 авг '13 в 07:30

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

PHP позволяет делать сравнения, которые на самом деле не имеют смысла. Пример:

$y = "wauv";
$x = false;
if ($x == $y)
    ...

Хотя это допускает некоторые интересные "горячие клавиши", вы должны остерегаться, поскольку функция, которая возвращает то, что она не должна (например, "ошибка" вместо числа), не будет поймана, и вам будет интересно, что же произошло.

В PHP == сравнивает значения и при необходимости выполняет преобразование типа (например, строка "12343sdfjskfjds" станет "12343" в целочисленном сравнении). === будет сравнивать значение И тип и вернет false, если тип не совпадает.

Если вы заглянете в руководство по PHP, то увидите, что многие функции возвращают "ложь" в случае сбоя функции, но они могут вернуть 0 в успешном сценарии, поэтому они рекомендуют делать "if (function()!==" ложно)"чтобы избежать ошибок.

3

Источник

user9479 26 фев '09 в 11:27

Вы должны использовать === для проверки, является ли функция или переменная ложной, а не просто равной ложной (ноль или пустая строка).

$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, что будет равно ложному в тесте

if ($pos == false)

или же

if (!$pos)

что не то, что вы хотите здесь.

2

Источник

user1142 17 сен '08 в 07:07

Что касается того, когда использовать один над другим, возьмите, например, fwrite() функция в PHP.

Эта функция записывает содержимое в файловый поток. Согласно PHP, "fwrite() возвращает количество записанных байтов или FALSE при ошибке.". Если вы хотите проверить, был ли вызов функции успешным, этот метод имеет недостатки:

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

Он может вернуть ноль (и считается успешным), и ваше состояние все еще срабатывает. Правильный путь будет:

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

2

Источник

user63414 26 фев '09 в 11:25

PHP является свободно типизированным языком. Использование оператора двойного равенства позволяет свободно проверять переменную.

Слабая проверка значения позволит некоторым подобным, но не равным значениям равняться одному и тому же:

""
ноль
ложный
0

Все эти значения будут равны как равные, используя оператор двойного равенства.

2

Источник

user53954 27 янв '16 в 21:34

Все ответы до сих пор игнорируют опасную проблему с ===. Попутно было отмечено, но не подчеркнуто, что integer и double - это разные типы, поэтому следующий код:

$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n ==  $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );

дает:

 equal
 not equal

Обратите внимание, что это НЕ случай "ошибки округления". Два числа в точности равны последнему биту, но они имеют разные типы.

Это неприятная проблема, потому что программа, использующая ===, может успешно работать годами, если все числа достаточно малы (где "достаточно мало" зависит от оборудования и ОС, на которой вы работаете). Однако, если случайно целое число оказывается достаточно большим, чтобы его можно было преобразовать в двойное, его тип изменяется "навсегда", даже если последующая операция или множество операций может вернуть его к небольшому целому значению. И это становится хуже. Он может распространяться - инфекция двойственности может передаваться всем, к чему она касается, по одному расчету за раз.

В реальном мире это, вероятно, будет проблемой в программах, которые обрабатывают даты после 2038 года, например. В настоящее время меткам времени UNIX (количество секунд с 1970-01-01 00:00:00 UTC) потребуется более 32 бит, поэтому их представление "волшебным образом" переключится на удвоение в некоторых системах. Поэтому, если вы вычислите разницу между двумя значениями, вы можете получить пару секунд, но в виде двойного числа, а не целочисленного результата, полученного в 2017 году.

Я думаю, что это намного хуже, чем преобразования между строками и числами, потому что это неуловимо. Мне легко отслеживать, что такое строка и что такое число, но отслеживать количество бит в числе мне не по силам.

Итак, в приведенных выше ответах есть несколько хороших таблиц, но нет различия между 1 (как целое число) и 1 (тонкое двойное число) и 1.0 (очевидное двойное число). Кроме того, совет, что вы всегда должны использовать === и никогда не ==, не очень хорош, потому что === иногда терпит неудачу, когда == работает правильно. Кроме того, JavaScript не эквивалентен в этом отношении, потому что он имеет только один тип чисел (внутренне он может иметь различные побитовые представления, но это не вызывает проблем для ===).

Мой совет - не используйте ни один. Вам нужно написать свою собственную функцию сравнения, чтобы действительно исправить этот беспорядок.

2

Источник

user3298321 08 май '17 в 22:05

<?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

Источник

user1691723 18 сен '15 в 00:51

Есть два различия между == а также === в 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() в тестах выше.

1

Источник

user4215651 12 сен '18 в 16:15

php == это оператор сравнения, который сравнивает значение переменных. Но === сравнивает значение и тип данных.

Например,

<?php 
  $var1 = 10;
  $var2 = '10';

  if($var1 == $var2) {
    echo 'Variables are equal';
  } else {
    echo 'Variables are not equal';
  }
?>

В этом случае вывод будет "Переменные равны", даже если их типы данных различны.

Но если мы будем использовать === вместо ==, результатом будет "Переменные не равны". Сначала php сравнивает значение переменной, а затем тип данных. Здесь значения одинаковы, но типы данных разные.

1

Источник

user9949370 04 фев '19 в 02:04

Разница между == (равно) и === (одинаково равно)

PHP предоставляет два оператора сравнения для проверки равенства двух значений. Основное различие между ними в том, что '=='проверяет, соответствуют ли значения двух операндов. С другой стороны, '===' проверяет значения, а также тип операндов equal or not.

== (равно)

=== (идентично равно)

Пример =>

      <?php 
    $val1 = 1234;
    $val2 = "1234";
    var_dump($val1 == $val2);// output => bool(true)
    //It checks only operands value
?> 


<?php 
    $val1 = 1234;
    $val2 = "1234";
    var_dump($val1 === $val2);// output => bool(false)
    //First it checks type then operands value
?>

если мы введем cast $val2 в (int) $val2 или (string)$val1, тогда он вернет true

         <?php 
        $val1 = 1234;
        $val2 = "1234";
        var_dump($val1 === (int)$val2);// output => bool(true)
        //First it checks type then operands value
    ?>

ИЛИ ЖЕ

        <?php 
        $val1 = 1234;
        $val2 = "1234";
        var_dump($val1 === (int)$val2);// output => bool(true)
        //First it checks type then operands value
    ?>

1

Источник

user3041435 12 фев '21 в 10:14

=== оператор должен сравнивать точное равенство содержимого в то время как == Оператор будет сравнивать семантическое равенство. В частности, это приведет строки к числам.

Равенство - обширный предмет. Смотрите статью в Википедии о равенстве.

1

Источник

user50902 26 фев '09 в 07:55

Переменные имеют тип и значение.

$ var = "test" - это строка, содержащая "test"
$ var2 = 24 - целое число, значение которого равно 24.

Когда вы используете эти переменные (в PHP), иногда у вас нет хорошего типа. Например, если вы делаете

if ($var == 1) {... do something ...}

PHP должен конвертировать ("для приведения") $var в целое число. В этом случае "$var == 1" имеет значение true, потому что любая непустая строка приводится к 1.

При использовании === вы проверяете, что значение И ТИП равны, поэтому "$var === 1" равно false.

Это полезно, например, когда у вас есть функция, которая может возвращать false (при ошибке) и 0 (результат):

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

Этот код неверен, как будто myFunction() возвращает 0, оно преобразуется в ложное, и у вас, похоже, есть ошибка. Правильный код:

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

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

1

Источник

user15209 17 сен '08 в 07:42

Другие вопросы по тегам php comparison operators equality identity-operator

user9021 17 сен '08 в 06:57 2008-09-17 06:57 · Accepted Answer · 2008-09-17 06:57

Разница между `==` а также `===`

Разница между слабо == оператор равенства и строгий === Идентичный оператор точно объясняется в руководстве:

Операторы сравнения

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ Пример │ Имя │ Результат │
├──────────┼───────────┼───────────────────────────────────────────────────────────┤
A $a ==  $b │ Равен │ ИСТИНА, если $ a равно жонглированию типов.            │
│$a === $b │ Одинаково │ ИСТИНА, если $ a равно $ b и они одного типа. │
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

свободно `==` равное сравнение

Если вы используете == оператор или любой другой оператор сравнения, который использует свободное сравнение, такое как !=, <> или же ==Вы всегда должны смотреть на контекст, чтобы увидеть, что, где и почему что-то преобразуется, чтобы понять, что происходит.

Правила конвертации

Таблица сравнения типов

В качестве ссылки и примера вы можете увидеть таблицу сравнения в руководстве:

Слабые сравнения с ==

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ array() │ "php" │  ""   │
├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤
│ ИСТИНА │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │
│ ЛОЖЬ │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │
│ 1       │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │
│ 0       │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ИСТИНА │
│ -1      │ ИСТИНА, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ИСТИНА, ЛОЖЬ, ЛОЖЬ, ИСТИНА, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ.
│ "1" │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │
│ "0"     │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │
-1 "-1" │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │
│ НУЛЬ │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ИСТИНА │
│ array() │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │
Ph "php" │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │
│ ""      │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ИСТИНА │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

строгий `===` идентичное сравнение

Если вы используете === оператор или любой другой оператор сравнения, который использует строгое сравнение, такое как !== или же ===тогда вы всегда можете быть уверены, что типы не будут волшебным образом меняться, потому что конвертация не будет происходить. Таким образом, при строгом сравнении тип и значение должны совпадать, а не только значение.

Таблица сравнения типов

В качестве ссылки и примера вы можете увидеть таблицу сравнения в руководстве:

Строгое сравнение с ===

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ │ │ ИСТИНА │ ЛОЖЬ │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ array () │ "php" │ "" │ ├─ ────────┼───────┼───────┼───────┼───────┼───────┼─ ──────┼───────┼───────┼───────┼─────────┼───────┼─ ──────┤ │ ИСТИНА │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ │ 1 │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, ЛОЖЬ, 1 │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ │ "0" │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ -1 │ ЛОЖЬ -1 │ "│ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ" ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛЖ │ ЛОЖЬ │ │ массив () │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │
│ "php"   │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ "ЛОЖЬ" ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ЛОЖЬ │ ИСТИНА │ └─────────┴────────────┴──────┴─────────────┴┴ ───────┴───────┴───────┴───────┴───────┴───────┴── ─────┴─────────┴───────┴───────┘

Чем отличаются операторы сравнения PHP (== double equals) и тождества (=== triple equals)?

23 ответа

Разница между == а также ===

свободно == равное сравнение

Правила конвертации

Таблица сравнения типов

строгий === идентичное сравнение

Таблица сравнения типов

PHP Двойные Равные == диаграмма равенства:

PHP Тройные Равные === Диаграмма равенства:

Медитация Гуру

Надежда:

Двойное равенство PHP == :

PHP Triple Equals === :

Два массива с разными типами ключей

Объекты

Разница между `==` а также `===`

свободно `==` равное сравнение

строгий `===` идентичное сравнение

PHP Двойные Равные `==` диаграмма равенства:

PHP Тройные Равные `===` Диаграмма равенства:

Двойное равенство PHP `==` :

PHP Triple Equals `===` :