# JavaScript Arithmetic Posted by

# JavaScript Arithmetic

## JavaScript Arithmetic Operators

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

Operator Description
Subtraction
* Multiplication
** Exponentiation (
ES2016
)
/ Division
% Modulus (Remainder)
++ Increment
Decrement

## Arithmetic Operations

A typical arithmetic operation operates on two numbers.

The two numbers can be literals:

### Example

var x = 100 + 50;

or variables:

var x = a + b;

or expressions:

### Example

var x = (100 + 50) * 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
100 + 50

The

operator (
``` + ```

var x = 5;
var y = 2;
var z = x + y;

## Subtracting

The

subtraction

operator (
``` - ```
) subtracts numbers.

var x = 5;
var y = 2;
var z = x – y;

## Multiplying

The

multiplication

operator (
``` * ```
) multiplies numbers.

var x = 5;
var y = 2;
var z = x * y;

## Dividing

The

division

operator (
``` / ```
) divides numbers.

var x = 5;
var y = 2;
var z = x / y;

## Remainder

The

modulus

operator (
``` % ```
) returns the division remainder.

### Example

var x = 5;
var y = 2;
var z = x % y;

In arithmetic, the division of two integers produces a

quotient

and a

remainder

.

In mathematics, the result of a

modulo operation

is the

remainder

of an arithmetic division.

## Incrementing

The

increment

operator (
``` ++ ```
) increments numbers.

var x = 5;
x++;
var z = x;

## Decrementing

The

decrement

operator (
``` -- ```
) decrements numbers.

var x = 5;
x–;
var z = x;

## Exponentiation

The

exponentiation

operator (
``` ** ```
) raises the first operand to the power of the second operand.

### Example

var x = 5;
var z =
x ** 2;          // result is 25

x ** y produces the same result as
``` Math.pow(x,y) ```
:

### Example

var x = 5;
var z =
Math.pow(x,2);   // result is 25

## Operator Precedence

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

### Example

var x = 100 + 50 * 3;

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

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
``` + ```
) and subtraction (
``` - ```
).

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

### Example

var x = (100 + 50) * 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 = 100 + 50 – 3;

## JavaScript Operator Precedence Values

Pale red entries indicates ECMAScript 2015 (ES6) or higher.

Value Operator Description Example
20 ( ) Expression grouping (3 + 4)
19 . Member person.name
19 [] Member person[“name”]
19 () Function call myFunction()
19 new Create new Date()
17 ++ Postfix Increment i++
17 Postfix Decrement i–
16 ++ Prefix Increment ++i
16 Prefix Decrement –i
16 ! Logical not !(x==y)
16 typeof Type typeof x
15 ** Exponentiation (ES2016) 10 ** 2
14 * Multiplication 10 * 5
14 / Division 10 / 5
14 % Division Remainder 10 % 5
13 + Addition 10 + 5
13 Subtraction 10 – 5
12 << Shift left x << 2
12 >> Shift right x >> 2
12 >>> Shift right (unsigned) x >>> 2
11 < Less than x < y
11 <= Less than or equal x <= y
11 > Greater than x > y
11 >= Greater than or equal x >= y
11 in Property in Object “PI” in Math
11 instanceof Instance of Object instanceof Array
10 == Equal x == y
10 === Strict equal x === y
10 != Unequal x != y
10 !== Strict unequal x !== y
9 & Bitwise AND x & y
8 ^ Bitwise XOR x ^ y
7 | Bitwise OR x | y
6 && Logical AND x && y
5 || Logical OR x || y
4 ? : Condition ? “Yes” : “No”
3 += Assignment x += y
3 /= Assignment x /= y
3 -= Assignment x -= y
3 *= Assignment x *= y
3 %= Assignment x %= y
3 <<= Assignment x <<= y
3 >>= Assignment x >>= y
3 >>>= Assignment x >>>= y
3 &= Assignment x &= y
3 ^= Assignment x ^= y
3 |= Assignment x |= y
2 yield Pause Function yield x
1 , Comma 5 , 6

Expressions in parentheses are fully computed before the value is
used in the rest of the expression.

## Exercise:

Divide
``` 10 ```
by
``` 2 ```
```alert(10  2);