Open In App

JavaScript Arithmetic Operators

JavaScript Arithmetic Operators are the operators that operate upon the numerical values and return a numerical value. Any kind of arithmetic operations performance requires these operators.

Assignment Operators list

There are many arithmetic operators as shown in the table with the description.

OPERATOR NAME

USAGE

OPERATION

Addition Operatora+bAdd two numbers or concatenate the string
Subtraction Operatora-bDifference between the two operators
Multiplication Operatora*bMultiply two number
Division Operatora/bFind the quotient of two operands
Modulus Operatora%bFind the remainder of two operands
Exponentiation Operatora**bRaise the Left operator to the power of the right operator 
Increment Operatora++
++a
Return the operand and then increase by one
Increase operand by one and then return
Decrement Operatora--
--a
Return operand and then decrease by one
Decrease operand by one and then return
Unary Plus(+)+aConverts NaN to number
Unary Negation (-)-aConverts operand to negative

Examples of JavaScript Arithmetic Operators

Addition (+)

The addition operator takes two numerical operands and gives their numerical sum. It also concatenates two strings or numbers.

Example: In this example we are adding two numbers performs addition, while adding a number and a string results in concatenation.

// Number + Number => Addition 
let x = 1 + 2
console.log(x)

// Number + String => Concatenation
let y =  5 + "hello" 
console.log(y)

Output
3
5hello

Subtraction (-)

The subtraction operator gives the difference between two operands in the form of numerical value.

Example: In this example we are subtracting two numbers results in subtraction, but subtracting a string from a number results in "NaN".

// Number - Number => Subtraction 
let x = 10 - 7 
console.log(x)

let y = "Hello" - 1 
console.log(y)

Output
3
NaN

Multiplication (*)

The multiplication operator gives the product of operands where one operand is a multiplicand and another is multiplier.

Example: In this example we are multiplying two numbers results in multiplication. Infinity multiplied by a finite number yields Infinity, and other types result in "NaN".

// Number * Number => Multiplication
let x = 3 * 3 
let y = -4 * 4 
console.log(x)
console.log(y)

let a = Infinity * 0 
let b = Infinity * Infinity 
console.log(a)
console.log(b)
let z = 'hi' * 2 
console.log(z)

Output
9
-16
NaN
Infinity
NaN

Division (/)

The division operator provides the quotient of its operands where the right operand is the divisor and the left operand is the dividend.

Example: In this example we are dividing two numbers results in division. Division by zero yields Infinity, and dividing zero by zero results in "NaN".

// Number / Number => Division
let x = 5 / 2
let y = 1.0 / 2.0
console.log(x)
console.log(y)


let a = 3.0 / 0
let b = 4.0 / 0.0
console.log(a)
console.log(b)
let z = 2.0 / -0.0
console.log(z)

Output
2.5
0.5
Infinity
Infinity
-Infinity

Modulus (%)

The modulus operator returns the remainder left over when a dividend is divided by a divisor. The modulus operator is also known as the remainder operator. It takes the sign of the dividend.

Example: In this example JavaScript's modulus operator (%) returns the remainder after division of one number by another. Negative numbers yield negative results.

// Number % Number => Modulus of the number
let x = 9 % 5
let y = -12 % 5
let z = 1 % -2
let a = 5.5 % 2
let b = -4 % 2
let c = NaN % 2

console.log(x)
console.log(y)
console.log(z)
console.log(a)
console.log(b)
console.log(c)

Output
4
-2
1
1.5
-0
NaN

Exponentiation (**)

The exponentiation operator gives the result of raising the first operand to the power of the second operand. The exponentiation operator is right-associative. 

In JavaScript, it is not possible to write an ambiguous exponentiation expression i.e. you cannot put an unary operator (+ / - / ~ / ! / delete / void) immediately before the base number.

Example: In this example JavaScript's exponentiation operator (**) raises one number to the power of another. It calculates powers, including negative exponents and decimals.

// Number ** Number => Exponential of the number

// let x = -4 ** 2 // This is an incorrect expression
let y = -(4 ** 2) 
let z = 2 ** 5 
let a = 3 ** 3
let b = 3 ** 2.5 
let c = 10 ** -2 
let d = 2 ** 3 ** 2 
let e = NaN ** 2

console.log(y)
console.log(z)
console.log(a)
console.log(b)
console.log(c)
console.log(d)
console.log(e)

Output
-16
32
27
15.588457268119896
0.01
512
NaN

Increment (++)

The increment operator increments (adds one to) its operand and returns a value.

Example: In this example JavaScript increment and decrement operators modify variables by either increasing or decreasing their values by one, with prefix or postfix notation.

// Postfix 
let a = 2;
b = a++; // b = 2, a = 3

// Prefix
let x = 5;
y = ++x; // x = 6, y = 6

console.log(a)
console.log(b)
console.log(x)
console.log(y)

Output
3
2
6
6

Decrement (- -)

The decrement operator decrements (subtracts one from) its operand and returns a value.

Example: In this exampel Prefix decrement operator decreases variable before it's used; Postfix decreases after the current expression.

// Prefix
let a = 2;
b = --a; 

// Postfix 
let x = 3;
y = x--;
 
console.log(a)
console.log(b)
console.log(x)
console.log(y)

Output
1
1
2
3

Unary Negation(-)

This is a unary operator i.e. it operates on a single operand. It gives the negation of an operand.

Example: In this example The unary negation operator (-) flips the sign of a number; converts non-numbers to numbers.

let a = 3;
b = -a; 

// Unary negation operator
// can convert non-numbers
// into a number
let x = "3";
y = -x; 
  
console.log(a)
console.log(b)
console.log(x)
console.log(y)

Output
3
-3
3
-3

Unary Plus(+)

This is a way to convert a non-number into a number. Although unary negation (-) also can convert non-numbers, unary plus is the fastest and preferred way of converting something into a number, because it does not perform any other operations on the number.

Example: In this example The unary plus operator (+) converts operands to numbers; true to 1, false and null to 0.

let a =  +4     
let b = +'2'   
let c = +true  
let x = +false 
let y = +null
     
console.log(a)
console.log(b)
console.log(c)
console.log(x)
console.log(y)

Output
4
2
1
0
0

Supported Browsers: The browsers supported by all JavaScript Arithmetic operators are listed below:

We have a complete list of Javascript operators, to check those please go through this Javascript Operators Complete reference article.

We have a Cheat Sheet on Javascript where we covered all the important topics of Javascript to check those please go through Javascript Cheat Sheet-A Basic guide to JavaScript.

Article Tags :