# JavaScript Arithmetic Operators Tutorial

In this section, we will see what the Arithmetic operators are and how to use them in JavaScript.

Note: In this section, we’re assuming you already familiar with the JavaScript operators in general.

## What is Arithmetic Operators in JavaScript?

There are multiple operators that can be used for basic mathematical operations. These operators are in the category of the Arithmetic operators.

## List of Arithmetic Operators in JavaScript

In the table below you can see the list of these operators:

 Operator Symbol Addition Operator + Subtraction Operator – Multiplication Operator * Division Operator / Exponentiation Operator ** Modulus Operator % Increment Operator ++ Decrement Operator —

## JavaScript Addition `+` Operator

When we want to add two Number type values to each other, we can use the addition `+` operator. The operands of this operator can be primitive values of type BigInt and Number, a function call that results such type of value or an expression that results a numeric value.

## Addition `+` Operator Syntax:

`LeftOperand + RightOperand`

## Example: using Addition `+` operator in JavaScript

```const res = 12300 + 3422;

console.log(res);```

Output:

`15722`

The addition operator is also overridden to work with String values as well. This means if the type of one of the involved operands is `String`:

1. The execution engine will coerce the other non-String operand into String type by running the `ToString` operation.
2. After that, it will concatenate both operands on each other.

## Example: Addition operator in JavaScript

```const res = "12300" + 3422;

console.log(res);```

Output:

`123003422`

If the operands are of type non-Number but also non-String, the execution engine will run the ToNumber operation on those operands to coerce them into a value of type Number.

## Example: JavaScript Addition Operator

```const res = true + false;

console.log(res);```

Output:

`1`

## JavaScript Subtraction `-` Operator

We use this operator when we want to subtract one value from another in the JavaScript.

Note: the involved operands can be either a constant value like (10, 4 ,2, 43.22 etc.), the result of calling a function or the value of a variable.

## Subtraction `-` Operator Syntax:

`LeftOperand - RightOperand`

## Example: using subtraction `-` operator in JavaScript

```const numOne = 12300;

const numTwo = 3422;

const res = numOne - numTwo;

console.log(res);```

Output:

`8878`

If the type of involved operands is something other than `Number`, the execution engine will run the `ToNumber` operation on those operands to coerce the type into Number.

## Example: JavaScript subtraction operator

```const numOne = "12300";

const numTwo = 3422;

const res = numOne - numTwo;

console.log(res);```

Output:

`8878`

## JavaScript Multiplication `*` Operator

When we want to multiply two values into each other, we use multiplication `*` operator.

## Multiplication `*` Operator Syntax:

`LeftOperand * RightOperand`

## Example: using multiplication `*` operator in JavaScript

```const numOne = 23;

const numTwo = 34;

const res = numOne * numTwo;

console.log(res);```

Output: 782

Note: if the type of the involved operands is not `Number`, the execution engine will invoke the `ToNumber` operation on those operands to coerce the type into Number.

## Example: JavaScript multiplication operator

```const numOne = 23;
const numTwo = 34;
const res = numOne * numTwo;
console.log(res);
```

Output: 6800

## JavaScript Division `/` Operator

On the contrary, to the multiplication operator, this operator is used to divide the operand on the left side by the operand on the right side of the division `/` operator.

## Division `/` Operator Syntax:

`LeftOperand / RightOperand`

## Example: using division `/` operator in JavaScript

```const numOne = 100;

const numTwo = 34;

const res = numOne / numTwo;

console.log(res);```

Output: 2.9411764705882355

Note: if the type of the involved operands is not `Number` the execution engine will run the `ToNumber` operation on those operands to coerce the type into Number.

## Example: JavaScript division operator

```const obj = {
valueOf(){
return 200;
}
}
const numTwo = 34;
const res = obj * numTwo;
console.log(res);
```

Output:

`2.9411764705882355`

## JavaScript Exponentiation `**` Operator

This operator is used to raise the value of the left operand to the power of the right operand and then return the result.

## Exponentiation `**` Operator Syntax:

`LeftOperand ** RightOperand`

## Example: using exponentiation `**` operator in JavaScript

```const res = 100 ** 2;

console.log(res);```

Output: 10000

Note: just like the other operators you saw so far, if the operands involved is not of type Number, the execution engine will run the `ToNumber` operation on those operands to coerce the value into Number type.

## Example: JavaScript Exponential Operator

```const obj = {
valueOf(){
return 100;
}
}
const numTwo = 34;
const res = obj / numTwo;
console.log(res);
```

Output: 10000

## JavaScript Modulus `%` Operator

Let me ask a question: how many 3s are in 10?

If you look carefully, it is 3. This is because if we multiply 3 to 4 we will get 12 and which passes the value 10 by two, but if we multiply 3 by 3, the result becomes 9. Now if we subtract the value 10 from 9 what’s the remainder? It is 1.

We use modulus operator to get that remainder.

## Modulus `%` Operator Syntax:

`LeftOperand % RightOperand`

## Example: using modulus `%` operator in JavaScript

```const res = 10 % 3;

console.log(res);```

Output:

`1`

Note: the type coercion will also apply on the operands of this operator if they are of type other than `Number`.

## JavaScript Increment `++` Operator

This operator is used to increase the value assigned to a variable by one.

Note: only those identifiers that are created via either `var` or `let` keyword can use this operator. This is because the value of that variable will be increased by one and so we can’t use an identifier that is created via the `const` keyword.

Remember: the value of the constant identifier won’t change.

This operator can be set on the left or right side of the target variable.

## Increment `++` Operator Syntax:

```++Operand

Operand++```

## Example: using increment `++` operator in JavaScript

```var valueRight = 13;

var valueLeft = 13;

var left = ++valueLeft;

var right = valueRight++;

console.log(`left: \${left}, right: \${right}, valueRight: \${valueRight}`)```

Output:

`left: 14, right: 13, valueRight: 14`

## JavaScript Increment Operator Differences

If the `++` operator appeared on the left side of a variable like ` var left = ++valueLeft;` that means first increase the value assigned to the operand (in this case `valueLeft`) and then proceed to the rest of operations. So the assigned value to the `left` variable will be 14.

On the other hand, if the `++` operator appeared on the right side of a variable like ` var right = valueRight++;`, the value assigned to the operand (in this case `valueRight`) will be increased by one, but this is only guaranteed for the next time we call the target variable.

So the final value that is assigned to the variable `right` in this example is 13 because the value of the `valueRight` did not change right away and the `right` variable took the old value of the valueRight variable.

Note: if the type of the involved operand is not `Number`, the execution engine will coerce the target operand by running the `ToNumber` operation on it.

## Example: JavaScript Increment Operator

```var valueRight = '13';

var valueLeft = '13';

var left = ++valueLeft;

var right = valueRight++;

console.log(`left: \${left}, right: \${right}, valueRight: \${valueRight}`)```

Output:

`left: 14, right: 13, valueRight: 14`

## JavaScript Decrement `–` Operator

This operator is used to decrease the value assigned to a variable by one.

Notes:

• This operator can be set on the left and right side of the target variable.
• Rules that applied to `++` operator also apply to `–` operator.

## Decrement `–` Operator Syntax:

```--Operand

Operand--```

## Example: using decrement `–` operator in JavaScript

```var valueRight = 13;

var valueLeft = 13;

var left = --valueLeft;

var right = valueRight-- + valueRight;

console.log(`left: \${left}, right: \${right}, valueRight: \${valueRight}`);```

Output:

`left: 12, right: 25, valueRight: 12`

Note: The basic arithmetic operations mentioned in this section apply to operands from left to right.

For example, if we have `var res = 10/2; ` the value 10 is divided by 2 not vice versa!