*974*

Table of Contents

In this tutorial, you’ll learn about JavaScript Operators like Addition, Subtraction, Multiplication, Division, Assignment and more.

An `operator`

is a mathematical symbol that produces a result based on one or more values (or variables or **operands**).

In JavaScript, operators are same as mathematics. An **operator performs some operation on single or multiple operands** (data value) and produces a result. i.e. For example, in `3 + 2`

, the `+`

sign is an operator and 3 is left side operand and 2 is right side operand. The `+`

operator performs the addition of two numeric values and returns a result.

## Types of JavaScript Operators

- Arithmetic Operators
- Comparison Operators
- Logical Operators
- Assignment Operators
- Conditional Operators
- Ternary Operator

### Arithmetic Operators

Arithmetic operators are used to perform mathematical operations between numeric operands.

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

+ | Adds two numeric operands. |

– | Subtract right operand from left operand |

* | Multiply two numeric operands. |

/ | Divide left operand by right operand. |

% | Modulus operator. Returns remainder of two operands. |

++ | Increment operator. Increase operand value by one. |

— | Decrement operator. Decrease value by one. |

Let’s understand, how arithmetic operators perform different tasks on operands.

**Addition, Subtraction, Multiplication, Division, Modulus Operations**

```
var x = 3, y = 9;
var z = x + y; //performs addition and returns 12
z = y - x; //performs subtraction and returns 6
z = x * y; //performs multiplication and returns 27
z = y / x; //performs division and returns 3
z = x % 2; //returns division remainder 1
```

**Post and Pre Increment/Decrement**

The `++`

and `--`

operators are unary operators. It works with either left or right operand only. When used with the left operand, e.g., `x++`

, it will increase the value of `x`

when the program control goes to the next statement.

In the same way, when it is used with the right operand, e.g., `++x`

, it will increase the value of `x`

there only. Therefore, `x++`

is called post-increment, and `++x`

is called pre-increment.

```
var x=6;
x++; //post-increment, x will be 6 here and 7 in the next line
++x; //pre-increment, x will be 8 here
x--; //post-decrement, x will be 8 here and 7 in the next line
--x; //pre-decrement, x will be 6 here
```

Note : In above explanation operations are performed with respect to previous instruction.

**String Concatenation**

The `+`

operator performs concatenation operation when one of the operands is of string type.

```
var a = 5, b = "Hello ", c = "World!", d = 10;
a + b; //returns "5Hello "
b + c; //returns "Hello World!"
a + d; //returns 15
b + true; //returns "Hello true"
c - b; //returns NaN; - operator can only used with numbers
```

### Comparison Operators

JavaScript provides comparison operators that compare two operands and return a boolean value `true`

or `false`

.

Operators | Description |
---|---|

== | Compares the equality of two operands without considering type. |

=== | Compares equality of two operands with type. |

!= | Compares inequality of two operands. |

> | Returns a boolean value true if the left-side value is greater than the right-side value; otherwise, returns false. |

< | Returns a boolean value true if the left-side value is less than the right-side value; otherwise, returns false. |

>= | Returns a boolean value true if the left-side value is greater than or equal to the right-side value; otherwise, returns false. |

<= | Returns a boolean value true if the left-side value is less than or equal to the right-side value; otherwise, returns false. |

Let’s understand, how Comparison Operators perform different tasks on operands.

```
var a = 15, b = 20, c = "25";
var x = a;
a == c; // returns true
a === c; // returns false
a == x; // returns true
a != b; // returns true
a > b; // returns false
a < b; // returns true
a >= b; // returns false
```

### Logical Operators

In JavaScript, the logical operators are used to combine two or more conditions. JavaScript provides the following logical operators.

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

&& | `&& ` is known as AND operator. It checks whether two operands are non-zero or not (0, false, undefined, null or “” are considered as zero). It returns 1 if they are non-zero; otherwise, returns 0. |

|| | `||` is known as OR operator. It checks whether any one of the two operands is non-zero or not (0, false, undefined, null or “” is considered as zero). It returns 1 if any one of of them is non-zero; otherwise, returns 0. |

! | `!` is known as NOT operator. It reverses the boolean result of the operand (or condition). `!false` returns `true` , and `!true` returns `false` . |

Let’s understand, how Logical Operators perform different tasks on operands.

```
var a = 5, b = 10;
(a != b) && (a < b); // returns true
(a > b) || (a == b); // returns false
(a < b) || (a == b); // returns true
!(a < b); // returns false
!(a > b); // returns true
```

### Assignment Operators

JavaScript provides the assignment operators to assign values to variables with less key strokes.

Assignment operators | Description |
---|---|

= | Assigns right operand value to the left operand. |

+= | Sums up left and right operand values and assigns the result to the left operand. |

-= | Subtract right operand value from the left operand value and assigns the result to the left operand. |

*= | Multiply left and right operand values and assigns the result to the left operand. |

/= | Divide left operand value by right operand value and assign the result to the left operand. |

%= | Get the modulus of left operand divide by right operand and assign resulted modulus to the left operand. |

Let’s understand, how Assignment Operators perform different tasks on operands.

```
var x = 5, y = 10, z = 15;
x = y; //x would be 10
x += 1; //x would be 6
x -= 1; //x would be 4
x *= 5; //x would be 25
x /= 5; //x would be 1
x %= 2; //x would be 1
```

### Ternary Operator

JavaScript provides a special operator called ternary operator `:?`

that assigns a value to a variable based on some condition. This is the short form of the if else condition.

`<condition> ? <value1> : <value2>;`

The ternary operator starts with conditional expression followed by the `?`

operator. The second part (after `?`

and before `:`

) will be executed if the condition turns out to be true. Suppose, the condition returns `false`

, then the third part (after : ) will be executed.

```
var a = 10, b = 5;
var c = a > b? a : b; // value of c would be 10
var d = a > b? b : a; // value of d would be 5
```

Having fun learning JavaScript!

## 2 comments

This is really helpful, keep posting such Daily Dose on JS….

Sure Adarsh!

Comments are closed.