# JavaScript Math Operators | Developer.com

Certainly one of JavaScript’s most vital contributions to the evolution of the Web is that it offloaded a lot of the server’s workload to the shopper, thereby considerably lowering each the quantity and period of community calls. With a full-featured set of math operators and features at its disposal, JavaScript may effectively carry out advanced calculations inside the browser. If you’re pretty new to JavaScript, or math for that matter, this internet growth tutorial will introduce you to JavaScript’s many math operators, the varieties of numbers in JavaScript, and operator priority guidelines.

**Learn:** Greatest On-line Programs to Study JavaScript

## Arithmetic Operators

There are various varieties of operators in JavaScript. These which pertain to math are referred to as *Arithmetic operators*. In contrast with Java’s operators, JavaScript has one additional: the *Exponentiation* ******, as of ECMAScript 2016. It, and the opposite arithmetic operators, are listed within the desk beneath, together with their syntax, definitions, and examples:

Operator | Syntax | Instance | Definition |
---|---|---|---|

Addition | `+` |
`x + y` |
Sum of `x` and `y` |

Subtraction | `-` |
`x - y` |
Distinction of `x` and `y` |

Multiplication | `*` |
`x * y` |
Product of `x` and `y` |

Division | `/` |
`x / y` |
Quotient of `x` and `y` |

Modulo | `%` |
`x % y` |
The rest of `x / y` |

Exponentiation | `**` |
`x ** y` |
`x` to the `y` energy |

Increment | `++` |
`x++/++x` |
`x` plus one |

Decrement | `--` |
`x--/--x` |
`x` minus one |

## Numbers in JavaScript

Now that now we have gone over the Arithmetic operators, we are going to want some numbers on which to use them. Some programming languages assist many alternative information sorts to accommodate quite a lot of numbers, similar to **int**, **float**, **double**, and so on… JavaScript solely has one information kind for numbers, the aptly named **Quantity**. It makes it so much simpler to carry out calculations as a result of, no matter kind of numbers you’re working with, you may deal with them in precisely the identical means. OK, fact be instructed, JavaScript has a second quantity kind, **BigInt**, that’s used for very giant integers. That being stated, for the needs of this tutorial, we are going to simply deal with **Quantity** values.

We will simply show that totally different sorts of numbers are all handled as the identical datatype by JavaScript utilizing the **typeof** operator. Listed here are the outcomes for an integer and float:

const myInt = 15; const myFloat = 6.667; console.log(typeof myInt); //quantity console.log(typeof myFloat); //quantity

### What are operand, unary, and binary in JavaScript?

Earlier than we get to some examples of working with Arithmetic operators in JavaScript, let’s shortly go over some sensible terminology, particularly: “operand”, “unary”, and “binary”.

An *operand* is what operators are utilized to. As an illustration, within the addition of **99 + 1** there are two operands: the left operand is **99** and the fitting operand is **1**.

There are two varieties of operators, as follows:

- An operator is
*unary*if it has a single operand. For instance, the*unary Incrementor*(**++**) provides 1 to a quantity. - An operator is
**binary**if it has two operands. Within the**99 + 1**instance above, the**+**is a*binary operator*as a result of it goes between two values.

## Methods to Use Unary and Binary Operators in JavaScript

Eventually, it’s time to see the JavaScript math operators in motion. Every operator is launched with a remark and introduced in the identical order as above:

// ADDITION let sum = 10 + 40; console.log(sum); // 50 // We will additionally use the addition operator with two variables. For instance: let worth = 9.99, transport = 2.99; let complete = worth + transport; console.log(complete); // 12.98 // SUBTRACTION let end result = 20 - 5; console.log(end result); // 15 // MULTIPLICATION let end result = 2 * 9; console.log(end result); // 18 // If both worth isn't a quantity, the JavaScript engine implicitly converts it right into a quantity earlier than performing the calculation. For instance: let end result="5" * 3; console.log(end result); // 15 // DIVISION let end result = 25 / 5; console.log(end result); // 5 // Once more, if both worth isn't a quantity, the JavaScript engine converts it right into a quantity first. For instance: let end result = 20 / '4'; console.log(end result); // 5; // MODULUS let a = 10; let b = 3; let c = a % b; console.log(c); // 1; /* The INCREMENTOR and DECREMENTOR operators could be positioned earlier than (prefix) or after (postfix) their operands, in order that they're evaluated both earlier than or after the increment/decrement operation, respectively. */ // INCREMENTOR let a = 5; let b = ++a; // a is incremented earlier than task console.log(a, b); // 6, 6 let a = 5; let b = a++; // a is incremented after task console.log(a, b); // 6, 5 // DECREMENTOR let a = 5; let b = --a; // a is decremented earlier than task console.log(a, b); // 4, 4 let a = 5; let b = a--; // a is decremented after task console.log(a, b); // 4, 5 // EXPONENTIATION // a ** b produces the identical end result as Math.pow(a,b): let a = 5; let b = a ** 2; console.log(b); // 25

There’s a demo of the above script in codepen.

## Operator Priority in JavaScript

*Operator priority *describes the order through which operations are carried out in an arithmetic expression. Simply as you discovered in grade faculty math, multiplication (*****) and division (**/**) have increased priority than addition (**+**) and subtraction (**–**), that means these calculations get carried out *first*. Therefore, **10 + 4 / 2** can be equal to **12** and never **7**. To override the default priority, we are able to enclose the operations that we wish carried out first inside *parentheses*, as in **(10 + 4) / 2**. Operations contained in the parentheses are computed first, going from the innermost on outwards. In the meantime, a number of operations with the identical priority (like addition and subtraction) are computed from left to proper. Acquired all that? Now, here’s a take a look at:

(3 * (10 / (6 - 4))) + 2 = ?

The reply is **17**. The steps taken by the JavaScript engine are:

(3 * (10 / 2)) + 2 (3 * 5) + 2 15 + 2 17

## Closing Ideas on JavaScript Math Operators

This internet growth tutorial launched JavaScript’s many math operators, the varieties of numbers in JavaScript, and operator priority guidelines. Though the principles are pretty straight-forward, in case you are ever uncertain of the right way to write an expression you may all the time consider it within the browser console: