Оператори порівняння

JavaScript має як строге порівняння, так і порівняння з перетворенням типів. Строге порівняння (===) є істинним лише в тому випадку, якщо операнди мають однаковий тип, а їхній зміст співпадає. Найчастіше вживане абстрактне порівняння (==) приводить операнди до спільного типу перед виконанням порівняння. Для абстрактних порівнянь (наприклад, <=) операнди спочатку приводяться до простих типів, потім приводяться до спільного типу, а вже тоді порівнюються.

Рядки порівнюються на основі стандартного лексикографічного упорядкування, використовуючи значення Unicode.

Особливості порівнянь:

• Два рядки строго рівні, якщо мають однакову послідовність символів, однакову довжину та однакові символи на відповідних позиціях.
• Два числа строго рівні, якщо вони чисельно рівні (мають однакове числове значення). 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'

• Object.is()
• Math.sign()
• Перевірка на рівність та однаковість