Java Script Operators

JavaScript Operator Types

Here is a list of different JavaScript operators you will learn in this tutorial:
1. Arithmetic Operators
2. Assignment Operators
3. Comparison Operators
4. Logical Operators
5. Bitwise Operators
6. String Operators
7. Miscellaneous Operators

1. JavaScript Arithmetic Operators

We use arithmetic operators to perform arithmetic calculations like addition,
subtraction, etc. For example,
5 - 3; // 2

Here, we used the - operator to subtract 3 from 5.

Commonly Used Arithmetic Operators

Operator Name Example

+ Addition 3 + 4 // 7

- Subtraction 5 - 3 // 2

* Multiplication 2 * 3 // 6

/ Division 4 / 2 // 2

% Remainder 5 % 2 // 1

++5 or 5++ //
++ Increment (increments by 1)
6

--4 or 4-- //
-- Decrement (decrements by 1)
3

** Exponentiation (Power) 4 ** 2 // 16
Example 1: Arithmetic Operators in JavaScriptlet x = 5;

// addition operator
console.log("Addition: x + 3 = ", x + 3);

// subtraction operator
console.log("Subtraction: x - 3 =", x - 3);

// multiplication operator
console.log("Multiplication: x * 3 =", x * 3);

// division operator
console.log("Division: x / 3 =", x / 3);

// remainder operator
console.log("Remainder: x % 3 =", x % 3);

// increment operator
console.log("Increment: ++x =", ++x);

// decrement operator
console.log("Decrement: --x =", --x);

// exponentiation operator
console.log("Exponentiation: x ** 3 =", x ** 3);

Output

Addition: x + 3 = 8
Subtraction: x - 3 = 2
Multiplication: x * 3 = 15
Division: x / 3 = 1.6666666666666667
Remainder: x % 3 = 2
Increment: ++x = 6
Decrement: --x = 5
Exponentiation: x ** 3 = 125

Note: The increment operator ++ adds 1 to the operand. And, the decrement
operator -- decreases the value of the operand by 1.
To learn more, visit Increment ++ and Decrement -- Operators.
2. JavaScript Assignment Operators
We use assignment operators to assign values to variables. For example,
let x = 5;

Here, we used the = operator to assign the value 5 to the variable x.

Commonly Used Assignment Operators

Operato
Name Example
r

= Assignment Operator a = 7;

+= Addition Assignment a += 5; // a = a + 5

-= Subtraction Assignment a -= 2; // a = a - 2

Multiplication
*= a *= 3; // a = a * 3
Assignment

/= Division Assignment a /= 2; // a = a / 2

%= Remainder Assignment a %= 2; // a = a % 2

Exponentiation
**= a **= 2; // a = a**2
Assignment

Example 2: Assignment Operators in JavaScript

// assignment operator
let a = 7;
console.log("Assignment: a = 7, a =", a);

// addition assignment operator

a += 5; // a = a + 5
console.log("Addition Assignment: a += 5, a =", a);

// subtraction assignment operator

a -= 5; // a = a - 5
console.log("Subtraction Assignment: a -= 5, a =", a);

// multiplication assignment operator

a *= 2; // a = a * 2
console.log("Multiplication Assignment: a *= 2, a =", a);

// division assignment operator

a /= 2; // a = a / 2
console.log("Division Assignment: a /= 2, a =", a);

// remainder assignment operator

a %= 2; // a = a % 2
console.log("Remainder Assignment: a %= 2, a =", a);

// exponentiation assignment operator

a **= 2; // a = a**2
console.log("Exponentiation Assignment: a **= 7, a =", a);

Output
Assignment: a = 7, a = 7
Addition Assignment: a += 5, a = 12
Subtraction Assignment: a -= 5, a = 7
Multiplication Assignment: a *= 2, a = 14
Division Assignment: a /= 2, a = 7
Remainder Assignment: a %= 2, a = 1
Exponentiation Assignment: a **= 7, a = 1

3. JavaScript Comparison Operators

We use comparison operators to compare two values and return a boolean value
(true or false). For example,

const a = 3, b = 2;
console.log(a > b);

// Output: true

Here, we have used the > comparison operator to check whether a (whose value
is 3) is greater than b (whose value is 2).
Since 3 is greater than 2, we get true as output.

Note: In the above example, a > b is called a boolean expression since

evaluating it results in a boolean value.
Commonly Used Comparison Operators

Operato
Meaning Example
r

3 == 5 gives us
== Equal to
false

!= Not equal to 3 != 4 gives us true

> Greater than 4 > 4 gives us false

< Less than 3 < 3 gives us false

Greater than or equal

>= 4 >= 4 gives us true
to

<= Less than or equal to 3 <= 3 gives us true

3 === "3" gives us

=== Strictly equal to
false

3 !== "3" gives us

!== Strictly not equal to
true

Example 3: Comparison Operators in JavaScript

// equal to operator
console.log("Equal to: 2 == 2 is", 2 == 2);

// not equal operator

console.log("Not equal to: 3 != 3 is", 3 != 3);

// strictly equal to operator

console.log("Strictly equal to: 2 === '2' is", 2 === '2');

// strictly not equal to operator

console.log("Strictly not equal to: 2 !== '2' is", 2 !== '2');
// greater than operator
console.log("Greater than: 3 > 3 is", 3 > 3);

// less than operator

console.log("Less than: 2 > 2 is", 2 > 2);

// greater than or equal to operator

console.log("Greater than or equal to: 3 >= 3 is", 3 >= 3);

// less than or equal to operator

console.log("Less than or equal to: 2 <= 2 is", 2 <= 2);

Output
Equal to: 2 == 2 is true
Not equal to: 3 != 3 is false
Strictly equal to: 2 === '2' is false
Strictly not equal to: 2 !== '2' is true
Greater than: 3 > 3 is false
Less than: 2 > 2 is false
Greater than or equal to: 3 >= 3 is true
Less than or equal to: 2 <= 2 is true
Difference between equality (== and !=) and strict equality (=== and !==) operators.

4. JavaScript Logical Operators

We use logical operators to perform logical operations on boolean expressions. For
example,

const x = 5, y = 3;
console.log((x < 6) && (y < 5));

// Output: true

Here, && is the logical operator AND. Since both x < 6 and y < 5 are true, the
combined result is true.
Commonly Used Logical Operators

Operator Syntax Description

true only if both

&& expression1 && expression1 and
(Logical
expression2 expression2 are
AND)
true

true if either
|| expression1 || expression1 or
(Logical
expression2 expression2 is
OR)
true

! false if expression
(Logical !expression
is true and vice versa
NOT)

Example 4: Logical Operators in JavaScript

let x = 3;

// logical AND
console.log((x < 5) && (x > 0)); // true
console.log((x < 5) && (x > 6)); // false

// logical OR
console.log((x > 2) || (x > 5)); // true
console.log((x > 3) || (x < 0)); // false

// logical NOT
console.log(!(x == 3)); // false
console.log(!(x < 2)); // true
5. JavaScript Bitwise Operators
We use bitwise operators to perform binary operations on integers.

Operator Description Example

& Bitwise AND 5 & 3 // 1

| Bitwise OR 5 | 3 // 7

^ Bitwise XOR 5 ^ 3 // 6

~ Bitwise NOT ~5 // -6

<< Left shift 5 << 1 // 10

Sign-
-10 >> 1 //
>> propagating
-5
right shift

Zero-fill -10 >>> 1 //

>>>
right shift 2147483643

Note: We rarely use bitwise operators in everyday programming. If you are interested,
visit JavaScript Bitwise Operators to learn more.
6. JavaScript String Concatenation Operator
In JavaScript, you can also use the + operator to concatenate (join) two
strings. For example,
let str1 = "Hel", str2 = "lo";
console.log(str1 + str2);

// Output: Hello

7. JavaScript Miscellaneous Operators

JavaScript has many more operators besides the ones we listed above.
You will learn about them in detail in later tutorials.

Operator Description Example

Comma: Evaluates
multiple operands
let a = (1,
, and returns the
3, 4); // 4
value of the last
operand.

(50 > 40) ?

Ternary: Returns
"pass" :
?: value based on
"fail"; //
the condition.
"pass"

Returns the data

typeof 3; //
typeof type of the
"number"
variable.
 Returns true if
the specified objectX
instanceof object is a valid instanceof
object of the ClassX
specified class.

Discards any
void(x) //
void expression's
undefined
return value.