JavaScript equality (2015 version)

Options

Keep in mind that anything entered into these fields will be evaluated as JavaScript code. Do not enter suspicious code from outside sources.

Explanation

Definition of == in the specification

First of all, as defined in the specification, there are seven different types: undefined, null, boolean, string, symbol (fairly new; these are values that can be used as attribute names but aren't strings), number (yes, NaN is a number), and object (which includes arrays, functions, dates, regular expressions, etc.). This definition differs from what the typeof operator uses, in that in this definition null is its own type (rather than being of type object), and that in this definition functions are a type of object (rather than being their own type). I'm going to use this definition of type, because the rules for equality are simpler that way.

Second, there are two different equality operators, == and ===. (!= and !== are the negation of == and ===, respectively.) If the two values being compared are the same type, these operators give the same result. If the two values being compared are different types, === always returns false, whereas == will generally perform some kind of type conversion. == has been in the language since the beginning, whereas === was added later. Some behaviors shared by both operators:

• Objects are compared by reference, whereas other values (including strings) are compared by value.
• 0 and -0 are distinct values (they result in different strings when converted to string), but they compare equal to each other.
• NaN does not equal any value, even itself. This is part of the IEEE floating point standard which is used by other languages as well; for instance, Java has the same behavior.
• 0 and 0.0, or 1 and 1.0, etc., are just two different ways of writing the same value. There's no (observable) difference between them, so they compare equal to each other.

Type conversions for == are summarized in the following table:

That is:

• undefined and null compare equal to each other, but not to anything else.
• If the values are different types from {boolean, number, string}, then they're both converted to numbers before comparing. true and false become 1 and 0. Converting a string to a number is different than calling parseFloat; parseFloat allows text after the number, which conversion to number doesn't allow, and conversion to number handles hexadecimal values (starting with 0x) which parseFloat doesn't. You can explicitly convert a string to a number using Number(str) (this is different from new Number(str)) or +str. Converting to a number returns NaN if it fails, which is not equal to anything (even itself), so a string that can't be converted to a number does not compare equal to any number.
• If one, but not both, of the values is an object, then it's converted to a primitive type, which is then compared using ==.

For object == primitive and primitive == object comparisons, the value depends on what valueOf returns. Unless you're doing something weird, the following table describes what happens (where obj is the object and val is the primitive value; +val converts a boolean or string into a number, as described above):

That is, conversion to primitive uses valueOf unless valueOf returns an object, in which case it uses toString. The default implementation of valueOf is basically return this; (and therefore returns an object).

Of the standard object types that don't implement valueOf, there's one that's likely to return a string that can convert into number, and that is Array. toString on an array converts each element to a string and puts commas between them, but doesn't put any sort of brackets around the array. For instance, ["hi","there"].toString() is "hi,there", and [2,3,4].toString() is "2,3,4". If you have an array of one element, which is either a number (like [5]) or a string containing a number (like ["5"]), then converting the array to a string will result in a string that can successfully be converted into a number. Because of this, [5] == 5 and ["5"] == 5 both return true.

The actual algorithm it uses: When the browser converts an object into a primitive type, it first tries the valueOf function. If valueOf returns undefined or null, then the values are not equal. If valueOf returns a primitive value, then it's compared to the other value using == comparison (i.e., it may be further converted to a different type). If valueOf is not a function or returns an object, then it tries toString instead, using the same rules that it uses for valueOf. If toString is not a function or returns an object, then it throws TypeError. However, there are two special cases:

• For Date objects, it uses the same algorithm, except it tries toString first and then valueOf. (I put date == number as return false just because the default toString returns a string that can't be converted into a number.)
• For Symbol objects, it bypasses valueOf and just directly uses the symbol value stored in the object internally. Since that's the same thing that valueOf returns, it normally doesn't make a difference, unless you change the valueOf function, in which case it will affect comparisons for Boolean, Number, and String objects, but not Symbol objects.

Source: ECMAScript 2015 Language Specification

See also: My original, non-interactive demo; Perl equality table (not mine)

Transitive closure of ==

== isn't transitive (that is, x == y and y == z does not imply that x == z), but what if it were? I mean, one way to do it is just to not do type conversion (like ===), but what if it did all the type conversion it currently does and still was transitive, what would that look like?

Cases:

• x == null or undefined and null or undefined == z: then x and z are both null or undefined, and therefore already equal to each other
• x == a boolean and that boolean == z: then x and z, converted to primitive then converted to number, both equal 0 or 1, so this is taken care of by the next case
• x == a number and that number == z: then x and z, converted to primitive then converted to number, equal the same number, and that number isn't NaN.
• x == a string and that string == z: then either the string is converted to a number in both comparisons (previous case), or it's converted to a number in one case (in which case z is either a string or an object that converts to a string, and that string can be converted into a number, which is taken care of by the previous case), or x and z both convert to the same string.
• x == a symbol and that symbol == z: then x and z, converted to a primitive, both convert to the same symbol
• x == an object and that object == z: then either the object converts to a primitive type in both cases (in which case it's the same as if a primitive type is used), or the object is exactly the same object as either x or z (or both).
• There isn't really a good way to take into consideration objects where valueOf or toString is not referentially transparent (e.g., {valueOf:function(){return Math.random();}}).

This is what I came up with:

function toPrimitive(obj) {
	if(obj == null || (typeof obj != 'object' && typeof obj != 'function'))
		return obj;
	if(obj.valueOf != null && obj.constructor != Date) {
		var v = obj.valueOf();
		if(v == null || (typeof v != 'object' && typeof v != 'function'))
			return v;
	}
	if(obj.toString != null) {
		var v = obj.toString();
		if(v == null || (typeof v != 'object' && typeof v != 'function'))
			return v;
	}
	// my implementation doesn't handle case where a Date object doesn't
	// have a toString method that returns a string, nor where constructor
	// was assigned explicitly, nor where a Symbol object has a modified
	// valueOf method
	throw new TypeError();
}

// transitive closure of ==
function transitiveEquals(x, y) {
	if(x == y) return true;
	// null and undefined are only equal to each other
	if(x == null || y == null)
		return false;
	// is there a value z such that x == z and z == y?
	// x and y convert to the same primitive value:
	var x_prim = toPrimitive(x), y_prim = toPrimitive(y);
	if(x_prim == null || y_prim == null)
		return false;
	if(x_prim == y_prim)
		return true;
	// z is number: x == z iff toPrimitive(z) is not a symbol and
	// +toPrimitive(x) == z
	if(typeof x_prim != 'symbol' && typeof y_prim != 'symbol' &&
	   +x_prim == +y_prim)
		return true;
	return false;
}