Over a million developers have joined DZone.

Equality in JavaScript

DZone's Guide to

Equality in JavaScript

· Web Dev Zone
Free Resource

Start coding today to experience the powerful engine that drives data application’s development, brought to you in partnership with Qlik.

There are two operators for comparing values in JavaScript: strict equality === and “normal” (or lenient) equality ==. Many style guides (correctly) tell programmers to avoid lenient equality and always use strict equality. This post explains why.

Whenever appropriate, related sections in the ECMAScript 5 language specification [1] are mentioned in square brackets.

Two ways of comparing

  • The strict equality operator === only considers values equal that have the same type.
  • The lenient equality operator == tries to convert values of different types, before comparing like strict equality.
Lenient equality causes two problems:
  • The conversion rules are counter-intuitive and do things you might not expect.
  • As the operator is so forgiving, type errors can remain hidden longer.

Strict equals ===

[ES5 11.9.6] Comparing two values. Values with different types are never equal. If both values have the same type then the following assertions hold.
  • undefined === undefined
  • null === null
  • Two (primitive) numbers:
        NaN !== _  // any value including NaN
    x === x
    +0 === -0
    for any number x. Thus equality is not transitive in JavaScript, because NaN is not equal to itself.
  • Two booleans, two strings (primitive): obvious results
  • Two objects (including arrays and functions): x === y only if x and y are the same object(!). That is, if you want to compare different objects, you have to do it manually.
    > var a = NaN;
    > a === a
    > var b = {}, c = {};
    > b === c
    > b === b
    > "abc" === new String("abc")
    false // different types (left: primitive, right: object)

Equals ==

[ES5 11.9.3] Comparing two values. If both values have the same type: compare with ===. Otherwise:
  1. undefined == null
  2. One number, one string: convert the string to a number
  3. A boolean and a non-boolean: convert the boolean to a number and then perform the comparison.
  4. Comparing a string or a number to an object: try to convert the object to a primitive and then make the comparison.
(3) leads to a weird idiosyncrasy where numbers greater than 1 are true in if statements, but not equal to true:
    > 0 == false
    > 1 == true
    > 2 == true
    > 2 ? true : false
    true // because 2 !== 0
Equality and strings:
    > "" == 0
    > "123" == 123
    > "" == false
    > "1" == true
    > "2" == true
    > "true" == true
    > "2" ? true : false
    true // because string is non-empty
    > "abc" == new String("abc")
    true // right side converted to primitive


From http://www.2ality.com/2011/06/javascript-equality.html

Create data driven applications in Qlik’s free and easy to use coding environment, brought to you in partnership with Qlik.


Opinions expressed by DZone contributors are their own.


Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.


{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}