Fun with JavaScript Numbers

Data types are an essential component of every programming language, and numbers are perhaps the most important of all data types. After all, computers are really just expensive calculators. Like any worthwhile programming language, JavaScript supports numerical data. However, like many other aspects of JavaScript, numbers have several intricacies which can bite you if you’re not careful. This article explores numerical data and some of its quirks.

Note - Before reading this article, you should have a basic familiarity with JavaScript data types.

The Number Type

In JavaScript, all numbers are represented using the Number data type. This includes integers, real numbers, hexadecimal numbers, and numbers written in scientific notation. The following example verifies this by applying the typeof operator to a variety of numbers. Each application of typeof in this example returns number.

typeof(100);
typeof(3.14);
typeof(0xDEADBEEF);
typeof(7.89e2);

In the previous example, the numbers took on a variety of formats. However, internally, all JavaScript numbers are actually represented as IEEE 754 floating point data. This is important because it means that JavaScript has no concept of integers, despite the language’s parseInt() function. It also means that JavaScript math is not 100% accurate. For example, consider the following expression.

(0.1 + 0.2) === 0.3

If you are unfamiliar with floating point numbers, you would certainly expect this expression to evaluate to true. After all, 0.1 + 0.2 does equal 0.3. However, due to the way floating point numbers work, the sum is actually 0.30000000000000004. The difference is slight, but it is enough to cause the entire expression to evaluate as false.

Positive and Negative Zero

Another quirk of the IEEE 754 standard is the signed zero. This results in two zeroes – a positive zero, +0, and a negative zero, -0. This may seem strange, but the fun is just beginning. Clearly, these are two distinct values, otherwise there would only be a single zero. However, if you display either of the zeroes, the sign is dropped. For example, the following code attempts to display the two zero values, side-by-side.

alert((+0) + " " + (-0));
// displays 0 0

To make matters worse, JavaScript’s comparison operators can’t seem to tell the two values apart either, as shown in the following example.

alert((+0 === -0));
// displays true
alert((-0 < +0));
// displays false

There is a fairly simple workaround for this problem. In JavaScript, division by zero yields Infinity. Similarly, division by negative zero yields -Infinity. Therefore, to determine if a number is equal to -0, we must check that it is a zero, then perform division with it as the denominator, and check for -Infinity as shown below.

function isNegativeZero(x) {
  return (x === 0 && (1/x) === -Infinity);
}

Not-a-Number

JavaScript actually defines a number named Not-a-Number, or NaN. NaN is a falsy value that is used to represent non-numbers as numbers. This value is interesting because its very name precludes it from being a number, yet typeof(NaN) is number. NaN is also fun because it is the only value in JavaScript that does not equal itself. For example, the following code will return false.

alert((NaN === NaN));
// displays false

Instead of using the comparison operators, you can test for NaN using the isNaN() function, as shown below.

isNaN(1);
// returns false
isNaN(NaN);
// returns true

However, isNaN() is also fun because it can be misleading. If you pass in a value that can be coerced to a number, isNaN() will return false. In the following example, isNaN() is called with several values that are clearly not numbers. However, each call returns false.

isNaN(true);
isNaN(false);
isNaN("");
isNaN(null);
// all return false

A better way to check for NaN is by exploiting the fact that it is not equal to itself. The following function tests for NaN using strict inequality. This function will only return true for the value NaN.

function isNotANumber(x) {
  return x !== x;
}

Other Fun Times

There are a few other scenarios which can lead to problems with numbers. For starters, you should beware of old browsers that allow global properties like Infinity, NaN, and undefined to be redefined to new values. For example, the following code could create a lot of problems if NaN is used frequently. Luckily, modern browsers will ignore assignments to the previously mentioned properties. Strict mode goes one step further by turning these silent failures into errors.

NaN = 1;
...
isNaN(NaN);
// now returns false

Another fun to diagnose error comes from adding a number and a string. An example of this is shown below. In this case, string concatenation overrides addition. This causes foo to be converted to the string "100". The final result is the string "1001", which is much different from the expected value of 101. This type of error is more common than you think, and tends to occur when reading user input.

var foo = 100;
var bar = "1";

alert(foo + bar);
// displays "1001"

Conclusion

This article has explored some of the idiosyncrasies of numbers in JavaScript. Hopefully, you now understand why these issues arise, and how you can avoid them. And, although you may not run into cases like the negative zero very often, at least now you are prepared.

Free book: Jump Start HTML5 Basics

Grab a free copy of one our latest ebooks! Packed with hints and tips on HTML5's most powerful new features.

  • Marcel

    Oh, you actually revealed a lot of “wat”s that I didn’t really know about. Thanks, it was a pleasant read.

    • http://www.cjihrig.com Colin Ihrig

      Glad you enjoyed it! Thanks for reading.

  • Kais

    I think that the most funniest one and the strangest feature is the last example but it is not complete, hope that you can add the second example described below :)

    if we have:
    var foo = 100;
    var bar = “1”;
    alert(foo + bar);
    // displays “1001”

    But what about this:
    alert(bar – foo)
    // displays “-99″, it is strange !

    • http://www.cjihrig.com Colin Ihrig

      Yes, string concatenation overloads the + operator, but there is no corresponding operation for – so it behaves differently. Thanks for pointing that out!