JavaScript Arithmetic Operators

Last Updated : 22 Mar, 2024

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

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

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.

Javascript ```// 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”.

Javascript ```// 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”.

Javascript ```// 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”.

Javascript ```// 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.

Javascript ```// 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.

Javascript ```// 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.

• If used postfix with the operator after the operand (for example, x++), then it increments and returns the value before incrementing.
• If used prefix with the operator before the operand (for example, ++x), then it increments and returns the value after incrementing.

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.

Javascript ```// 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.

• If used postfix, with operator after operand (for example, x–), then it decrements and returns the value before decrementing.
• If used prefix, with the operator before the operand (for example, –x), then it decrements and returns the value after decrementing.

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

Javascript ```// 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.

Javascript ```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.

Javascript ```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.

Previous
Next