# JavaScript Arithmetic

### JavaScript Arithmetic Operators

Arithmetic operators perform arithmetic on numbers (literals or variables).

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

+ | Addition |

- | Subtraction |

* | Multiplication |

/ | Division |

% | Modulus |

++ | Increment |

-- | Decrement |

### Arithmetic Operations

A typical arithmetic operation operates on two numbers.

The two numbers can be literals:

### Example

```
var x = 70 + 80;
```

or variables:

### Example

```
var x = a + b;
```

or expressions:

### Example

```
var x = (70 + 80) * a;
```

### Operators and Operands

The numbers (in an arithmetic operation) are called **operands**.

The operation (to be performed between the two operands) is defined by an **operator**.

Operand | Operator | Operand |
---|---|---|

70 | + | 80 |

The **addition** operator (+) adds numbers:

### Adding

```
var x = 4;
```

var y = 3;

var z = x + y;

The **subtraction** operator (-) subtracts numbers.

### Subtracting

```
var x = 4;
```

var y = 3;

var z = x - y;

The **multiplication** operator (*) multiplies numbers.

### Multiplying

```
var x = 4;
```

var y = 3;

var z = x * y;

The **division** operator (/) divides numbers.

### Dividing

```
var x = 4;
```

var y = 3;

var z = x / y;

The **modular** operator (%) returns the division remainder.

### Modulus

```
var x = 4;
```

var y = 3;

var z = x % y;

The **increment** operator (++) increments numbers.

### Incrementing

```
var x = 4;
```

x++;

var z = x;

The **decrement** operator (--) decrements numbers.

### Decrementing

```
var x = 4;
```

x--;

var z = x;

### Operator Precedence

Operator precedence describes the order in which operations are performed in an arithmetic expression.

### Example

```
var x = 70 + 80 * 3;
```

Is the result of example above the same as 180 * 3, or is it the same as 70 + 180?

Is the addition or the multiplication done first?

As in traditional school mathematics, the multiplication is done first.

Multiplication (*) and division (/) have higher **precedence** than
addition (+) and subtraction (-).

And (as in school mathematics) the precedence can be changed by using parentheses:

### Example

```
var x = (70 + 80) * 3;
```

When using parentheses, the operations inside the parentheses are computed first.

When many operations have the same precedence (like addition and subtraction), they are computed from left to right:

### Example

```
var x = 70 + 80 - 3;
```

### JavaScript Operator Precedence Values

Value | Operator | Description | Example |
---|---|---|---|

19 | ( ) | Expression grouping | (3 + 4) |

18 | . | Member | person.name |

18 | [] | Member | person["name"] |

17 | () | Function call | myFunction() |

17 | new | Create | new Date() |

16 | ++ | Postfix Increment | i++ |

16 | -- | Postfix Decrement | i-- |

14 | ++ | Prefix Increment | ++i |

14 | -- | Prefix Decrement | --i |

14 | ! | Logical not | !(x==y) |

14 | typeof | Type | typeof x |

14 | * | Multiplication | 10 * 4 |

14 | / | Division | 10 / 4 |

14 | % | Modulo division | 10 % 4 |

14 | ** | Exponentiation | 10 ** 3 |

13 | + | Addition | 10 + 4 |

13 | - | Subtraction | 10 - 4 |

13 | << | Shift left | x << 3 |

13 | >> | Shift right | x >> 3 |

11 | < | Less than | x < y |

11 | <= | Less than or equal | x <= y |

11 | > | Greater than | x > y |

11 | >= | Greater than or equal | x >= y |

10 | == | Equal | x == y |

10 | === | Strict equal | x === y |

10 | != | Unequal | x != y |

10 | !== | Strict unequal | x !== y |

6 | && | And | x && y |

4 | || | Or | x || y |

3 | = | Assignment | x = y |

3 | += | Assignment | x += y |

3 | -= | Assignment | x -= y |

3 | *= | Assignment | x *= y |

3 | /= | Assignment | x /= y |