## JS Tutorial

- JS HOME
- JS Introduction
- JS Where To
- JS Output
- JS Syntax
- JS Statements
- JS Comments
- JS Variables
- JS Operators
- JS Arithmetic
- JS Assignment
- JS Data Types
- JS Functions
- JS Objects
- JS Scope
- JS Events
- JS Strings
- JS String Methods
- JS Numbers
- JS Number Methods
- JS Math
- JS Random
- JS Dates
- JS Date Formats
- JS Date Methods
- JS Arrays
- JS Array Methods
- JS Array Sort
- JS Booleans
- JS Comparisons
- JS Conditions
- JS Switch
- JS Loop For
- JS Loop While
- JS Break
- JS Type Conversion
- JS Bitwise
- JS RegExp
- JS Errors
- JS Debugging
- JS Hoisting
- JS Strict Mode
- JS Style Guide
- JS Best Practices
- JS Mistakes
- JS Performance
- JS Reserved Words
- JS JSON
## JS Forms

- JS Forms
- Forms API
## JS Objects

- Object Definitions
- Object Properties
- Object Methods
- Object Prototypes
## JS Functions

- Function Definitions
- Function Parameters
- Function Invocation
- Function Closures
## JS HTML DOM

- DOM Intro
- DOM Methods
- DOM Document
- DOM Elements
- DOM HTML
- DOM CSS
- DOM Animations
- DOM Events
- DOM EventListener
- DOM Navigation
- DOM Nodes
- DOM Nodelist
## JS Browser BOM

- JS Window
- JS Screen
- JS Location
- JS History
- JS Navigator
- JS Popup Alert
- JS Timing
- JS Cookies
## JS AJAX

- AJAX Intro
- AJAX XMLHttp
- AJAX Request
- AJAX Response
- AJAX XML File
- AJAX PHP
- AJAX ASP
- AJAX Database
- AJAX Applications
## JS JSON

- JSON Intro
- JSON Syntax
- JSON vs XML
- JSON Data Types
- JSON Objects
- JSON Arrays
- JSON Parse
- JSON Stringify
- JSON PHP
- JSON HTML
- JSON JSONP

A typical thing to do with numbers is arithmetic.

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

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

+ | Addition |

- | Subtraction |

* | Multiplication |

/ | Division |

% | Modulus |

++ | Increment |

-- | Decrement |

A typical arithmetic operation operates on two numbers.

The two numbers can be literals:

var x = 100 + 50;

or variables:

var x = a + b;

or expressions:

var x = (100 + 50) * a;

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 **addition** operator (+) adds numbers:

var x = 5;

var y = 2;

var z = x + y;

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

var x = 5;

var y = 2;

var z = x - y;

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

var x = 5;

var y = 2;

var z = x * y;

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

var x = 5;

var y = 2;

var z = x / y;

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

var x = 5;

var y = 2;

var z = x % y;

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

var x = 5;

x++;

var z = x;

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

var x = 5;

x--;

var z = x;

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

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

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

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:

var x = 100 + 50 - 3;

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-- |

15 | ++ | Prefix Increment | ++i |

15 | -- | Prefix Decrement | --i |

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

15 | typeof | Type | typeof x |

14 | * | Multiplication | 10 * 5 |

14 | / | Division | 10 / 5 |

14 | % | Modulo division | 10 % 5 |

14 | ** | Exponentiation | 10 ** 2 |

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 |

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

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

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

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

6 | && | Logical and | x && y |

5 | || | Logical or | 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 |

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

Pale red entries indicates experimental or proposed technology (ECMASScript 2016 or ES7)

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