Javascript Operators
JavaScript includes operators same as other languages. An operator performs some operation on single or multiple operands (data value) and produces a result.
For example, in 1 + 2
, the +
sign is an operator and 1 is left side operand and 2 is right side operand.
The +
operator performs the addition of two numeric values and returns a result.
JavaScript includes following categories of 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. 
The following example demonstrates how arithmetic operators perform different tasks on operands.
let x = 5, y = 10;
let z = x + y; //performs addition and returns 15
z = y  x; //performs subtraction and returns 5
z = x * y; //performs multiplication and returns 50
z = y / x; //performs division and returns 2
z = x % 2; //returns division remainder 1
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 postincrement, and ++x
is called preincrement.
let x = 5;
x++; //postincrement, x will be 5 here and 6 in the next line
++x; //preincrement, x will be 7 here
x; //postdecrement, x will be 7 here and 6 in the next line
x; //predecrement, x will be 5 here
String Concatenation
The +
operator performs concatenation operation when one of the operands is of string type.
The following example demonstrates string concatenation even if one of the operands is a string.
let 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 leftside value is greater than the rightside value; otherwise, returns false. 
<  Returns a boolean value true if the leftside value is less than the rightside value; otherwise, returns false. 
>=  Returns a boolean value true if the leftside value is greater than or equal to the rightside value; otherwise, returns false. 
<=  Returns a boolean value true if the leftside value is less than or equal to the rightside value; otherwise, returns false. 
The following example demonstrates the comparison operators.
let a = 5, b = 10, c = "5";
let 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
a <= b; // returns true
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 nonzero or not (0, false, undefined, null or "" are considered as zero). It returns 1 if they are nonzero; otherwise, returns 0. 
   is known as OR operator. It checks whether any one of the two operands is nonzero or not (0, false, undefined, null or "" is considered as zero). It returns 1 if any one of of them is nonzero; 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 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 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.
let a = 10, b = 5;
let c = a > b? a : b; // value of c would be 10
let d = a > b? b : a; // value of d would be 5
 JavaScript includes operators that perform some operation on single or multiple operands (data value) and produce a result.
 JavaScript includes various categories of operators: Arithmetic operators, Comparison operators, Logical operators, Assignment operators, Conditional operators.
 Ternary operator ?: is a short form of ifelse condition.