JavaScript Tutorial
Arithmetic operators handle the math in JavaScript: addition, subtraction, multiplication, division, modulo, and exponentiation.
They are essential for anything from totals in a cart to time calculations and animation math.
Nearly every real program performs math. If you misunderstand arithmetic operators, you can create subtle logic and precision bugs.
Knowing how these operators behave with strings, floats, and edge cases keeps calculations reliable.
a + b // addition
a - b // subtraction
a * b // multiplication
a / b // division
a % b // remainder
a ** b // exponentiation
a++ // increment (postfix)
++a // increment (prefix)
a-- // decrement (postfix)
--a // decrement (prefix)console.log(5 + 3); // 8
console.log(10 - 4); // 6
console.log(3 * 7); // 21
console.log(15 / 3); // 5
console.log(17 % 5); // 2Addition, subtraction, multiplication, division, and modulo are the core arithmetic tools.
console.log(2 ** 3); // 8
console.log(16 ** 0.5); // 4 (square root)
console.log(2 ** 3 ** 2); // 512 (right-associative)Use `**` for powers and fractional exponents for roots.
Arithmetic operators power totals, averages, discounts, and time calculations. You use them for almost any numeric work in JavaScript.
The same operators also work with floating-point numbers, so be mindful of precision in money or measurement logic.
The `**` operator makes power calculations clear and readable. It is right-associative, so `2 ** 3 ** 2` means `2 ** (3 ** 2)`.
For roots, use fractional exponents like `16 ** 0.5` for square roots.
`++` and `--` update a variable by one. Prefix changes first, postfix changes after the expression returns.
These operators are handy in loops but can hurt readability in complex expressions.
JavaScript uses IEEE 754 floating-point numbers. That means `0.1 + 0.2` is not exactly `0.3`.
When precision matters, compare using a tolerance (like `Number.EPSILON`) or work with integers (cents instead of dollars).
let x = 5;
console.log(x++); // 5 (postfix)
console.log(x); // 6
console.log(++x); // 7 (prefix)
console.log(--x); // 6Prefix changes the value first, postfix returns first and then changes it.
const sum = 0.1 + 0.2;
console.log(sum); // 0.30000000000000004
const closeEnough = Math.abs(sum - 0.3) < Number.EPSILON;
console.log(closeEnough); // trueFloating-point arithmetic can be imprecise, so compare with a tolerance.
Without
// Without compound operators
let total = 10;
total = total + 5;
// Using Math.pow
const squared = Math.pow(4, 2);With
// With arithmetic operators
let total = 10;
total += 5;
const squared = 4 ** 2;Use a tolerance for comparisons or work with integers for money.
Convert explicitly with Number() to avoid accidental concatenation.
Avoid ++/-- in complex expressions for readability.
JavaScript returns Infinity, so guard before dividing.
It returns the remainder after division, often used for cycles or parity.
Binary floating-point cannot exactly represent some decimals.
Prefix increments before returning the value; postfix returns first, then increments.
Practice: Calculate a discounted price and tax. Use arithmetic operators and print the final amount.
const price = 120;
const discount = 0.2;
const taxRate = 0.18;
// TODO: compute final amount
One Possible Solution
const price = 120;
const discount = 0.2;
const taxRate = 0.18;
const afterDiscount = price - price * discount;
const final = afterDiscount + afterDiscount * taxRate;
console.log(final);Floating-point numbers cannot represent some decimals exactly. Use a tolerance or integer math for precision-sensitive work.
Yes. `a ** b` is equivalent to `Math.pow(a, b)` but more readable.
It returns the remainder after division, useful for cycles, parity checks, and wrapping indexes.
They are fine in loops, but can reduce clarity in complex expressions.
Run the arithmetic examples and change the values to see how each operator behaves.