Arithmetic operators in JavaScript are used to perform mathematical calculations on numeric values. They allow developers to perform operations such as addition, subtraction, multiplication, division, finding remainders, and calculating powers. JavaScript provides several arithmetic operators that are commonly used in calculations, counters, expressions, and programs that work with numeric data. Understanding these operators is important for performing mathematical operations correctly and writing effective JavaScript programs.

Table of Contents

---

What are Arithmetic Operators in JavaScript?

Arithmetic operators are symbols used to perform mathematical operations on values and variables. JavaScript supports arithmetic operators for addition, subtraction, multiplication, division, remainder, exponentiation, increment, and decrement.

Example:

// JavaScript program to demonstrate arithmetic operators
let a = 20;
let b = 5;
console.log(a + b);
console.log(a - b);
console.log(a * b);
console.log(a / b);
console.log(a % b);

Output:

25
15
100
4
0

Here, different arithmetic operators perform different mathematical operations on the values stored in a and b.

Types of Arithmetic Operators

JavaScript provides the following commonly used arithmetic operators.

Operator	Name	Description
+	Addition	Adds two values.
-	Subtraction	Subtracts one value from another.
*	Multiplication	Multiplies two values.
/	Division	Divides one value by another.
%	Modulus	Returns the remainder after division.
**	Exponentiation	Raises one value to the power of another.
++	Increment	Increases a value by 1.
--	Decrement	Decreases a value by 1.
+	Unary Plus	Converts a value to a number when possible.
-	Unary Minus	Converts a value to a number and changes its sign.

Addition Operator (+)

The addition operator is used to add two numeric values.

Example:

// JavaScript program to demonstrate the addition operator
let a = 15;
let b = 10;
let result = a + b;
console.log(result);

Output:

25

The values 15 and 10 are added, producing 25.

The + operator can also be used for string concatenation when one of the operands is a string.

Example:

// JavaScript program to demonstrate addition and string concatenation
let number = 10;
let text = "20";
console.log(number + text);

Output:

1020

Here, JavaScript converts the number into a string and performs string concatenation.

Subtraction Operator (-)

The subtraction operator is used to subtract one numeric value from another.

Example:

// JavaScript program to demonstrate the subtraction operator
let a = 30;
let b = 12;
let result = a - b;
console.log(result);

Output:

18

The value 12 is subtracted from 30, producing 18.

Multiplication Operator (*)

The multiplication operator is used to multiply two numeric values.

Example:

// JavaScript program to demonstrate the multiplication operator
let a = 8;
let b = 6;
let result = a * b;
console.log(result);

Output:

48

The values 8 and 6 are multiplied, producing 48.

Division Operator (/)

The division operator is used to divide one number by another.

Example:

// JavaScript program to demonstrate the division operator
let a = 20;
let b = 4;
let result = a / b;
console.log(result);

Output:

5

The value 20 is divided by 4, producing 5.

JavaScript can also return a decimal result when the division is not exact.

Example:

// JavaScript program to demonstrate division with a decimal result
let a = 10;
let b = 3;
let result = a / b;
console.log(result);

Output:

3.3333333333333335

Modulus Operator (%)

The modulus operator returns the remainder after dividing one number by another.

Example:

// JavaScript program to demonstrate the modulus operator
let a = 17;
let b = 5;
let result = a % b;
console.log(result);

Output:

2

When 17 is divided by 5, the remainder is 2.

The modulus operator is commonly used to determine whether a number is even or odd.

Example:

// JavaScript program to check whether a number is even or odd
let number = 12;
if (number % 2 === 0) {
    console.log("Even number");
} else {
    console.log("Odd number");
}

Output:

Even number

Exponentiation Operator (**)

The exponentiation operator is used to raise a number to a specified power.

Example:

// JavaScript program to demonstrate the exponentiation operator
let base = 2;
let exponent = 5;
let result = base ** exponent;
console.log(result);

Output:

32

The expression 2 ** 5 means that 2 is multiplied by itself five times.

Increment Operator (++)

The increment operator increases the value of a variable by 1.

Example:

// JavaScript program to demonstrate the increment operator
let number = 10;
number++;
console.log(number);

Output:

11

The value of number increases from 10 to 11.

The increment operator can be used in two forms.

Post-increment:

// JavaScript program to demonstrate post-increment
let number = 10;
console.log(number++);
console.log(number);

Output:

10
11

The current value is used first, and then the variable is increased by 1.

Pre-increment:

// JavaScript program to demonstrate pre-increment
let number = 10;
console.log(++number);

Output:

11

The variable is increased first, and then the updated value is used.

Decrement Operator (--)

The decrement operator decreases the value of a variable by 1.

Example:

// JavaScript program to demonstrate the decrement operator
let number = 10;
number--;
console.log(number);

Output:

9

The value of number decreases from 10 to 9.

The decrement operator can also be used in pre-decrement and post-decrement forms.

Example:

// JavaScript program to demonstrate pre-decrement and post-decrement
let number = 10;
console.log(number--);
console.log(number);
console.log(--number);

Output:

10
9
8

Unary Plus Operator (+)

The unary plus operator is placed before a single value and can convert a value into a number.

Example:

// JavaScript program to demonstrate the unary plus operator
let value = "25";
let number = +value;
console.log(number);
console.log(typeof number);

Output:

25
number

The string "25" is converted into the number 25.

Unary Minus Operator (-)

The unary minus operator converts a value into a number and changes its sign.

Example:

// JavaScript program to demonstrate the unary minus operator
let value = "25";
let number = -value;
console.log(number);
console.log(typeof number);

Output:

-25
number

The string "25" is converted into the number 25, and the unary minus changes it to -25.

Arithmetic Operators with Variables

Arithmetic operators can be used with variables to perform calculations.

Example:

// JavaScript program to perform arithmetic operations using variables
let price = 500;
let quantity = 3;
let total = price * quantity;
console.log(total);

Output:

1500

The price is multiplied by the quantity to calculate the total amount.

Arithmetic Operators with Strings

JavaScript handles arithmetic operations with strings differently depending on the operator. The + operator can perform string concatenation, while other arithmetic operators generally convert numeric strings into numbers.

Example:

// JavaScript program to demonstrate arithmetic operators with numeric strings
let a = "20";
let b = "5";
console.log(a + b);
console.log(a - b);
console.log(a * b);
console.log(a / b);

Output:

205
15
100
4

The + operator concatenates the strings, while -, *, and / convert the numeric strings into numbers before performing the operation.

Operator Precedence

When an expression contains multiple arithmetic operators, JavaScript follows operator precedence to determine the order in which the operations are performed.

Multiplication and division are generally performed before addition and subtraction.

Example:

// JavaScript program to demonstrate arithmetic operator precedence
let result = 10 + 5 * 2;
console.log(result);

Output:

20

The multiplication 5 * 2 is performed first, producing 10. Then 10 + 10 produces 20.

Parentheses can be used when a different order of evaluation is required.

Example:

// JavaScript program to demonstrate parentheses in arithmetic expressions
let result = (10 + 5) * 2;
console.log(result);

Output:

30

Here, the expression inside the parentheses is evaluated first.

Complete Program Using Arithmetic Operators

The following program demonstrates the commonly used arithmetic operators in JavaScript.

// JavaScript program to demonstrate arithmetic operators
let a = 20;
let b = 6;
console.log("Addition:", a + b);
console.log("Subtraction:", a - b);
console.log("Multiplication:", a * b);
console.log("Division:", a / b);
console.log("Modulus:", a % b);
console.log("Exponentiation:", a ** 2);
a++;
console.log("After increment:", a);
b--;
console.log("After decrement:", b);

Output:

Addition: 26
Subtraction: 14
Multiplication: 120
Division: 3.3333333333333335
Modulus: 2
Exponentiation: 400
After increment: 21
After decrement: 5

Advantages of Arithmetic Operators

1. Performing Calculations: Arithmetic operators allow JavaScript programs to perform mathematical calculations easily.
2. Working with Variables: They can be used with variables to calculate values dynamically during program execution.
3. Useful in Applications: Arithmetic operations are commonly required in applications such as calculators, billing systems, games, and financial programs.
4. Working with Conditions: Operators such as % are useful for checking conditions, such as determining whether a number is even or odd.
5. Efficient Expressions: Arithmetic operators allow multiple mathematical operations to be combined into a single expression.

Common Beginner Mistakes

1. Confusing + with Numerical Addition: Beginners may forget that the + operator can perform string concatenation when one operand is a string.
2. Confusing % with Division: The modulus operator returns the remainder rather than the complete division result.
3. Ignoring Operator Precedence: Beginners may expect arithmetic operations to execute strictly from left to right without considering operator precedence.
4. Confusing Pre-Increment and Post-Increment: The position of ++ changes when the value is increased relative to when the expression is evaluated.
5. Forgetting That Division Can Produce Decimals: JavaScript division does not automatically return an integer when the result contains a fractional part.

Conclusion

Arithmetic operators are fundamental JavaScript operators used to perform mathematical calculations. They include addition, subtraction, multiplication, division, modulus, exponentiation, increment, and decrement operators. JavaScript also provides unary operators for converting and changing numeric values. Understanding how these operators work, including operator precedence and type conversion, helps developers write accurate calculations and build reliable JavaScript applications.

FAQs

1. What are arithmetic operators in JavaScript?

Arithmetic operators are symbols used to perform mathematical operations such as addition, subtraction, multiplication, division, and finding the remainder.

2. What is the difference between / and % in JavaScript?

The / operator returns the result of division, while the % operator returns the remainder after division.

3. What does the ** operator do in JavaScript?

The ** operator performs exponentiation by raising the value on the left to the power specified by the value on the right.

4. What is the purpose of the ++ operator?

The ++ operator increases the value of a variable by 1.

5. What happens when the + operator is used with a string and a number?

JavaScript can convert the number into a string and concatenate the two values instead of performing numerical addition.