JavaScript має як строге порівняння, так і порівняння з перетворенням типів. Строге порівняння (===
) є істинним лише в тому випадку, якщо операнди мають однаковий тип, а їхній зміст співпадає. Найчастіше вживане абстрактне порівняння (==
) приводить операнди до спільного типу перед виконанням порівняння. Для абстрактних порівнянь (наприклад, <=
) операнди спочатку приводяться до простих типів, потім приводяться до спільного типу, а вже тоді порівнюються.
Рядки порівнюються на основі стандартного лексикографічного упорядкування, використовуючи значення Unicode.
The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.
Особливості порівнянь:
- Два рядки строго рівні, якщо мають однакову послідовність символів, однакову довжину та однакові символи на відповідних позиціях.
- Два числа строго рівні, якщо вони чисельно рівні (мають однакове числове значення). NaN не дорівнює нічому, в тому числі NaN. Додатні та від'ємні нулі дорівнюють один одному.
- Два булеві операнди строго рівні, якщо обидва є
true
, або обидва єfalse
. - Два окремі об'єкти ніколи не є рівними ні при строгому, ні при абстрактному порівнянні.
- Вираз, що порівнює об'єкти, істинний лише тоді, коли операнди посилаються на один і той самий об'єкт.
- Типи Null та Undefined строго рівні собі та абстрактно рівні один одному.
Оператори рівності
Рівність (==)
Оператор рівності перетворює операнди, якщо вони не однакового типу, і після цього застосовує строге порівняння. Якщо обидва операнди є об'єктами, JavaScript порівнює внутрішні посилання, які є рівними, якщо операнди посилаються на один і той самий об'єкт у пам'яті.
Синтаксис
x == y
Приклади
1 == 1 // true
'1' == 1 // true
1 == '1' // true
0 == false // true
0 == null // false
var object1 = {'key': 'value'}, object2 = {'key': 'value'};
object1.key == object2.key // true
0 == undefined // false
null == undefined // true
Нерівність (!=)
Оператор нерівності повертає true, якщо операнди не є рівними. Якщо два операнда не належать до одного типу, JavaScript намагається привести операнди до відповідного типу для порівняння. Якщо обидва операнда є об'єктами, JavaScript порівнює внутрішні посилання, які є нерівними, якщо операнди посилаються на різні об'єкти у пам'яті.
Синтаксис
x != y
Приклади
1 != 2 // true
1 != '1' // false
1 != "1" // false
1 != true // false
0 != false // false
Ідентичність / строга рівність (===)
Оператор ідентичності повертає true, якщо операнди строго рівні (див. вище) без приведення типів.
Синтаксис
x === y
Приклади
3 === 3 // true
3 === '3' // false
var object1 = {'key': 'value'}, object2 = {'key': 'value'};
object1 === object2 //false
Неідентичність / строга нерівність (!==)
Оператор неідентичності повертає true, якщо операнди не є рівними та/або не однакового типу.
Синтаксис
x !== y
Приклади
3 !== '3' // true
4 !== 3 // true
Оператори відношення
Кожен з цих операторів буде примусово приведений до простої величини перед порівнянням. Якщо обидва перетворюються на рядки, вони порівнюються з використанням лексикографічного порядку, інакше вони будуть перетворені на числа для порівняння. Порівняння із NaN
завжди поверне false
.
Більше ніж (>)
Оператор більше ніж повертає true, якщо значення лівого операнда більше за значення правого операнда.
Синтаксис
x > y
Приклади
4 > 3 // true
Більше чи дорівнює (>=)
Оператор більше чи дорівнює повертає true, якщо значення лівого операнда більше, або дорівнює значенню правого операнда.
Синтаксис
x >= y
Приклади
4 >= 3 // true
3 >= 3 // true
Менше ніж (<)
Оператор менше ніж повертає true, якщо значення лівого операнда менше значення правого операнда.
Синтаксис
x < y
Приклади
3 < 4 // true
Менше чи дорівнює (<=)
Оператор менше чи дорівнює повертає true, якщо значення лівого операнда менше або дорівнює значенню правого операнда.
Синтаксис
x <= y
Приклади
3 <= 4 // true
Застосування операторів порівняння
Стандартні оператори рівності (==
та !=
) використовують алгоритм абстрактної рівності для порівняння двох операндів. Якщо операнди належать до різних типів, алгоритм спробує привести їх до спільного типу перед порівнянням; наприклад, у виразі 5 == '5'
, рядок праворуч буде приведений до числа
перед здійсненням порівняння.
Оператори строгої рівності (===
та !==
) використовують алгоритм строгої рівності та призначені для виконання перевірки рівності операндів одного типу. Якщо операнди належать до різних типів, результат завжди буде false
, тому 5 !== '5'
.
Використовуйте оператори строгого порівняння, якщо операнди мають належати до вказаного типу, як і їх значення, або, якщо конкретний тип операндів має значення. Інакше, використовуйте стандартні оператори рівності, які дозволяють перевіряти ідентичність двох операндів, навіть якщо вони не належать до одного типу.
Коли в порівнянні застосовується перетворення типів (тобто, це не строге порівняння), JavaScript перетворює типи операндів String
, Number
, Boolean
або Object
наступним чином:
- При порівнянні числа й рядка, рядок конвертується в числове значення. JavaScript намагається конвертувати число у рядковому літералі в значення типу
Number
. Спочатку математичне значення виводиться з рядкового літерала. Далі ця величина округлюється до найближчого значення типуNumber
. - Якщо один з операндів належить до типу
Boolean
, цей операнд конвертується у 1, якщо він дорівнюєtrue
, і у +0, якщо він дорівнюєfalse
. - Якщо об'єкт порівнюється з рядком або числом, JavaScript намагається повернути значення об'єкта за замовчуванням. Оператори намагаються перетворити об'єкти на просте значення, рядок або
число
, використовуючи методи об'єктівvalueOf
таtoString
. Якщо спроба перетворення була невдалою, генерується помилка виконання. - Зауважте, що об'єкт перетворюється на просту величину тоді, й тільки тоді, коли порівнюється з простою величиною. Якщо обидва операнди є об'єктами, вони порівнюються як об'єкти, а тест на рівність істинний, тільки якщо вони обидва посилаються на один і той самий об'єкт.
// true, оскільки обидва операнди мають тип String (є рядковими примітивами):
'foo' === 'foo'
var a = new String('foo');
var b = new String('foo');
// false, оскільки a та b мають тип Object і посилаються на різні об'єкти
a == b
// false, оскільки a та b мають тип Object і посилаються на різні об'єкти
a === b
// true, оскільки a та 'foo' мають різні типи, але об'єкт (а)
// перетворюється на рядок 'foo' перед порівнянням
a == 'foo'
Специфікації
Специфікація | Статус | Коментар |
---|---|---|
ECMAScript 1st Edition (ECMA-262) | Standard | Початкове визначення. Реалізовано у JavaScript 1.0 |
ECMAScript 3rd Edition (ECMA-262) | Standard | Додані оператори === та !== . Реалізовано у JavaScript 1.3 |
ECMAScript 5.1 (ECMA-262) | Standard | Дано визначення у декільках секціях специфікації: Оператори відношення, Оператори рівності |
ECMAScript 2015 (6th Edition, ECMA-262) | Standard | Дано визначення у декільках секціях специфікації: Оператори відношення, Оператори рівності |
ECMAScript (ECMA-262) | Living Standard | Дано визначення у декільках секціях специфікації: Оператори відношення, Оператори рівності |