Over a million developers have joined DZone.

Equality in JavaScript

DZone's Guide to

Equality in JavaScript

· Web Dev Zone ·
Free Resource

Learn how error monitoring with Sentry closes the gap between the product team and your customers. With Sentry, you can focus on what you do best: building and scaling software that makes your users’ lives better.

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

What’s the best way to boost the efficiency of your product team and ship with confidence? Check out this ebook to learn how Sentry's real-time error monitoring helps developers stay in their workflow to fix bugs before the user even knows there’s a problem.


Opinions expressed by DZone contributors are their own.

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

{{ parent.tldr }}

{{ parent.urlSource.name }}