Working with Numbers in JavaScript

Numbers are fundamental to programming, and JavaScript makes working with them straightforward once you understand the basics. Unlike some programming languages that distinguish between different types of numbers (integers, floats, decimals), JavaScript treats all numbers as one data type, which simplifies things for beginners.

JavaScript's Number System

In JavaScript, all numbers are stored as 64-bit floating-point numbers, following the IEEE 754 standard. The IEEE 754 standard is an international specification that defines how computers represent and perform arithmetic on floating-point numbers, ensuring consistent behavior across different systems. This means you don't need to worry about declaring whether a number is an integer or has decimal places — JavaScript handles this automatically.

let wholeNumber = 42;
let decimal = 3.14;
let negative = -17;
let scientific = 2.5e6; // 2,500,000

console.log(typeof wholeNumber); // "number"
console.log(typeof decimal);     // "number"

Basic Arithmetic Operations

JavaScript supports all the standard mathematical operations you'd expect. The operators are intuitive and work just like a calculator:

let a = 10;
let b = 3;

console.log(a + b);  // 13 (addition)
console.log(a - b);  // 7  (subtraction)
console.log(a * b);  // 30 (multiplication)
console.log(a / b);  // 3.333... (division)
console.log(a % b);  // 1  (remainder/modulo)
console.log(a ** b); // 1000 (exponentiation)

The modulo operator (%) is particularly useful for determining if a number is even or odd, or for creating repeating patterns in your programs.

Working with Decimals and Precision

One important thing to understand about JavaScript numbers is that decimal arithmetic can sometimes produce unexpected results due to how computers store floating-point numbers:

console.log(0.1 + 0.2); // 0.30000000000000004 (not 0.3!)

// To handle this, you can round to a specific number of decimal places
let result = 0.1 + 0.2;
console.log(result.toFixed(2)); // "0.30" (as a string)
console.log(parseFloat(result.toFixed(2))); // 0.3 (as a number)

Useful Number Methods

JavaScript provides several built-in methods for working with numbers. Here are some of the most commonly used ones:

let number = 45.6789;

console.log(number.toFixed(2));    // "45.68" - rounds to 2 decimal places
console.log(Math.round(number));   // 46 - rounds to nearest integer
console.log(Math.floor(number));   // 45 - rounds down
console.log(Math.ceil(number));    // 46 - rounds up
console.log(Math.abs(-25));        // 25 - absolute value

Converting Strings to Numbers

Often you'll need to convert text input into numbers for calculations. JavaScript provides several ways to do this:

let stringNumber = "123";
let stringDecimal = "45.67";

// Using parseInt() and parseFloat()
console.log(parseInt(stringNumber));    // 123
console.log(parseFloat(stringDecimal)); // 45.67

// Using Number() constructor
console.log(Number(stringNumber));      // 123
console.log(Number(stringDecimal));     // 45.67

// Using the + operator (shorthand)
console.log(+stringNumber);             // 123

Note that parseInt() stops parsing when it encounters a non-digit character and can behave unexpectedly with certain inputs. It's recommended to always specify a radix (base) as the second parameter to avoid issues with octal or hexadecimal interpretation:

console.log(parseInt("10", 10));   // 10 (base 10)
console.log(parseInt("010", 10));  // 10 (not 8 in octal)

Checking for Valid Numbers

Sometimes you need to verify that a value is actually a valid number, especially when dealing with user input. The isNaN() function checks if a value is NaN (Not a Number) after attempting to convert it to a number:

console.log(isNaN("hello"));     // true - becomes NaN when converted
console.log(isNaN("123"));       // false - converts to valid number 123
console.log(Number.isInteger(5)); // true
console.log(Number.isInteger(5.5)); // false

For more precise checking, you might prefer Number.isNaN() which doesn't perform type conversion, or use typeof combined with !isNaN() for string inputs.

Generating Random Numbers

JavaScript's Math.random() function is perfect for creating random numbers, which is useful for games, simulations, or generating test data:

// Random decimal between 0 and 1
console.log(Math.random()); // e.g., 0.7834592947

// Random integer between 1 and 10
let randomInt = Math.floor(Math.random() * 10) + 1;
console.log(randomInt); // e.g., 7

What's Next

Now that you understand how to work with numbers in JavaScript, you're ready to tackle more complex programming concepts. In our next post, we'll explore JavaScript strings and how to manipulate text, which often works hand-in-hand with number operations when building real applications.