Performing math operations and calculus is a very common thing to do with any programming language.

JavaScript offers several operators to help us work with numbers.

## Operators

### Arithmetic operators

#### Addition (+)

```
const three = 1 + 2
const four = three + 1
```

The `+`

operator also serves as string concatenation if you use strings, so pay attention:

```
const three = 1 + 2
three + 1 // 4
'three' + 1 // three1
```

#### Subtraction (-)

```
const two = 4 - 2
```

#### Division (/)

Returns the quotient of the first operator and the second:

```
const result = 20 / 5 //result === 4
const result = 20 / 7 //result === 2.857142857142857
```

If you divide by zero, JavaScript does not raise any error but returns the `Infinity`

value (or `-Infinity`

if the value is negative).

```
1 / 0 //Infinity
-1 / 0 //-Infinity
```

#### Remainder (%)

The remainder is a very useful calculation in many use cases:

```
const result = 20 % 5 //result === 0
const result = 20 % 7 //result === 6
```

A reminder by zero is always `NaN`

, a special value that means “Not a Number”:

```
1 % 0 //NaN
-1 % 0 //NaN
```

#### Multiplication (*)

```
1 * 2 //2
-1 * 2 //-2
```

#### Exponentiation (**)

Raise the first operand to the power second operand

```
1 ** 2 //1
2 ** 1 //2
2 ** 2 //4
2 ** 8 //256
8 ** 2 //64
```

### Unary operators

#### Increment (++)

Increment a number. This is a unary operator, and if put before the number, it returns the value incremented.

If put after the number, it returns the original value, then increments it.

```
let x = 0
x++ //0
x //1
++x //2
```

#### Decrement (–)

Works like the increment operator, except it decrements the value.

```
let x = 0
x-- //0
x //-1
--x //-2
```

#### Unary negation (-)

Return the negation of the operand

```
let x = 2
-x //-2
x //2
```

#### Unary plus (+)

If the operand is not a number, it tries to convert it. Otherwise if the operand is already a number, it does nothing.

```
let x = 2
+x //2
x = '2'
+x //2
x = '2a'
+x //NaN
```

## Assignment shortcuts

The regular assignment operator, `=`

, has several shortcuts for all the arithmetic operators which let you combine assignment, assigning to the first operand the result of the operations with the second operand.

They are:

`+=`

: addition assignment`-=`

: subtraction assignment`*=`

: multiplication assignment`/=`

: division assignment`%=`

: remainder assignment`**=`

: exponentiation assignment

Examples:

```
const a = 0
a += 5 //a === 5
a -= 2 //a === 3
a *= 2 //a === 6
a /= 2 //a === 3
a %= 2 //a === 1
```

## Precedence rules

Every complex statement will introduce precedence problems.

Take this:

```
const a = 1 * 2 + 5 / 2 % 2
```

The result is 2.5, but why? What operations are executed first, and which need to wait?

Some operations have more precedence than the others. The precedence rules are listed in this table:

Operator | Description |
---|---|

`-` `+` `++` `--` |
unary operators, increment and decrement |

`*` `/` `%` |
multiply/divide |

`+` `-` |
addition/subtraction |

`=` `+=` `-=` `*=` `/=` `%=` `**=` |
assignments |

Operations on the same level (like `+`

and `-`

) are executed in the order they are found

Following this table, we can solve this calculation:

```
const a = 1 * 2 + 5 / 2 % 2
const a = 1 * 2 + 5 / 2 % 2
const a = 2 + 2.5 % 2
const a = 2 + 0.5
const a = 2.5
```