Numbers are the most basic data type there is, and require very
little explanation. As we saw in Chapter 2, *Lexical Structure*, numeric literals can be integer or
floating-point, and integers can be expressed in decimal, octal, or
hexadecimal notation. JavaScript differs from programming languages
like C and Java in that it does not make a distinction between
integer value and floating point values. All numbers in JavaScript
are represented as floating-point values. JavaScript represents
numbers using the standard 8-byte IEEE floating-point numeric
format, which means that it can represent numbers as large as
+/-1.7976931348623157x10^308,
and numbers as small as
+/-2.2250738585072014x10^-308.[2]

JavaScript programs work with numbers using the arithmetic
operators that the language provides. These include
`+` for addition, `-` for
subtraction, `*` for multiplication, and
`/` for division. Full details on these and
other arithmetic operators are in Chapter 4, *Expressions and Operators*.

In addition to these basic arithmetic operations, JavaScript
supports more complex mathematical operations through a large
number of mathematical functions that are a core part of the
language. For convenience, these functions are all stored as
properties of a single object named `Math`, and
so we use always use the literal name `Math` to
access them. For example, to compute the sine of the numeric
value `x`, we would write code like this:

And to compute the square-root of a numeric expression, we might
use code like this (note the use of the

`*`
operator for multiplication):

hypot = Math.sqrt(x*x + y*y);

See the Math object and subsequent listings in the reference
section of this book for full details on all the mathematical
functions supported by JavaScript.

There are several special numeric values used by JavaScript.
When a floating-point value becomes larger than the largest
representable type, the result is a special infinity value,
which JavaScript prints as `Infinity`. Similarly,
when a negative value becomes more negative than the most
negative representable number, the result is negative infinity,
printed as `-Infinity`. (Internet Explorer 3.0
prints these special infinity values in a less intuitive
fashion; this will be fixed.)

Another special JavaScript numeric value is returned when a
mathematical operation (such as division by zero) yields an
undefined result or an error. In this case, the result is the
special Not-a-Number value, printed as `NaN`.
The special Not-a-Number value has special behavior: it does
not compare equal to any number, including itself! For this
reason, a special function `isNaN()`
is required to test for this value. In Navigator 2.0, the
`NaN` value and the
`isNaN()` do not work correctly on
Windows and other platforms. On 2.0 Windows platforms, 0 is
returned instead of `NaN` when a numeric
value is undefined. Similarly, `NaN` does
not work in Internet Explorer 3.0, although it will in future
versions. In IE 3.0, `isNaN()` always returns
`false`, and functions return 0 instead of
`NaN`.

In Navigator 3.0 (but not IE 3.0), there are constants defined
for each of these special numeric values. These constants are
listed in Table 3.1.

Table 3.1: Special Numeric Constants
Constant |
Meaning |

`Number.MAX_VALUE` |
Largest representable number |

`Number.MIN_VALUE` |
Most negative representable number |

`Number.NaN` |
Special not-a-number value |

`Number.POSITIVE_INFINITY` |
Special value to represent infinity |

`Number.NEGATIVE_INFINITY` |
Special value to represent negative infinity |