The JavaScript arithmetic operators take numerical values as their left & right operands, perform the arithmetic operation, and return a numerical value. The JavaScript supports all the arithmetic operators like addition (+), subtraction (-), multiplication (*), division (/), etc. Note that all the numbers in JavaScript are represented as IEEE 754 floating-point numbers and use floating-point arithmetic.
Table of Contents
Arithmetic Operators
The following are the List of Arithmetic Operators in JavaScript
| Operator | Description |
|---|---|
| + | Addition |
| – | Subtraction |
| * | Multiplication |
| ** | Exponentiation |
| / | Division |
| % | Modulus (Remainder) |
| ++ | Increment |
| — | Decrement |
| + | Unary plus |
| – | Unary minus |
Addition (+)
The addition operator (+) is a binary operator, which calculates the sum of two numeric operands.
1 2 3 4 5 6 | let a = 12 let b = 2 let c = a+b; console.log(c) //14 |
If one of the operands is a string, then the + operator does a string concatenation
1 2 3 4 5 6 | let a = "Hello" let b = 2 let c = a+b; console.log(c) //Hello2 |
1 2 3 4 5 6 7 | let a = "12" let b = 2 let c = a+b; //string concatenation as the b is string console.log(c) //122 |
The booleans are implemented as numerical values with a single binary digit (i.e., 0 & 1). 1 is true & 0 is false.
1 2 3 4 5 | let a = true //boolean let b = 2 console.log(c) //3 because true is 1 |
1 2 3 4 5 6 | let a = false //boolean let b = 2 let c = b+a; console.log(c) //2 because false is 0 |
1 2 3 | console.log(true+true+true) //3 because true is 1. |
Subtraction (–)
The subtraction operator subtracts the right operand from the left operand. If any of the operands is not a number, then it returns a NaN
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | let a = 10 let b = 2 let c = a-b; console.log(c) //8 let d = b-a; console.log(d) //-8 //Boolean console.log(true-false) //1 true is 1, false is 0 console.log(2-true) //1 |
Converts strings to numbers.
1 2 3 4 5 | let a = "1" let b = "2" console.log(a-b); //-1 |
Subtraction, when one (or both) of the operand is not a number, always results in NaN
1 2 3 4 5 | let a = "Hello" let b = 2 console.log(a-b); //NaN |
Multiplication (*)
The multiplication operator (*) multiplies the left operand with the right operand.
1 2 3 4 5 | let a = 5 let b = 2 console.log(a*b); //10 |
Strings are converted to numbers.
1 2 3 4 5 6 | let a = "5" let b = "2" console.log(a*b); //10 |
1 2 3 4 | console.log(Infinity * 0) // NaN console.log(Infinity * Infinity) // Infinity |
Multiplication with non-numbers results in NaN.
1 2 3 | console.log("Hello" * 10) // NaN |
Division (/)
The division operator (/) divides the left operand (dividend) with the right operand (divisor).
Example
1 2 3 4 5 6 | console.log(10 / 2); //5 console.log(11 / 2); //5.5 |
Strings are converted to numbers.
1 2 3 4 5 | console.log(6 / '3'); //2 console.log('6' / '3'); //2 |
If the string is not a number, then the result is NaN.
1 2 3 4 5 | console.log(6 / 'a'); //NaN console.log(6 / '3a'); //NaN |
Booleans are numbers. True is 1 & false is 0
1 2 3 4 | console.log(6 / true); //6 true is 1 console.log(2 / false); //Infinity false is 0 |
Dividing by 0 results in Infinity
1 2 3 4 | console.log(2 / 0); //Infinity |
Modulus or Reminder (%)
The remainder operator (%) returns the remainder leftover of a division operation between the operands. The result always takes the sign of the dividend.
1 2 3 4 5 6 7 8 | console.log(12%5) //2 console.log(-12%5) //-2 console.log(-12%-5) //-2 console.log(12%-5) //2 |
Increment (++) & Decrement (—)
We use the increment & Decrement operators to increase or decrease the value of the variable by one. JavaScript uses the ++ (increment) & -- (decrement) to denote them. We can either prefix or Postfix these operators.
Increment & Decrement Operators in JavaScript
Unary plus (+) & Unary minus (–)
The unary plus operator (+) precedes its operand and converts it into a number. If it fails to convert the operand into a number, then it returns NaN. The unary (-) operator converts the operand into a number and negates it.
Unary plus & Unary minus operators in JavaScript
Exponentiation (**)
The exponentiation operator (**) returns the result of raising the first operand to the power of the second operand.
1 2 3 4 5 6 7 8 9 10 11 | console.log(3 ** 4); // 81 console.log(10 ** -2); // 0.01 console.log(2 ** 3 ** 2); // 512 console.log((2 ** 3) ** 2); // 64 console.log(2 ** (3 ** 2)); // 512 |
BigInt & Arithmetic Operators
The BigInt can be used with the following arithmetic operations. Addition (+), Subtraction (-), Multiplication (*), Exponentiation (%), Division (/), Modulus (Remainder) (%), Increment (++), Decrement (–).
Unary plus (+) & Unary minus (-) are not supported
The / division operator rounds of the final result to the whole number. For example, dividing 5/2 results in 2 and not 2.5. i.e it is an integer and not decimal.
Reference
Read More
- JavaScript Tutorial
- JavaScript Operators
- Arithmetic Operators
- Unary plus (+) & Unary minus (-)
- Increment & Decrement Operators
- Comparison or Relational Operators
- Strict Equality & Loose Equality Checker
- Ternary Conditional Operator
- Logical Operators
- Bitwise Operators
- Assignment Operators
- Nullish Coalescing Operator
- Comma Operator
- Operator Precedence
