When you start learning programming, one of the first things you use, are operators. In simple terms, operators in JavaScript are symbols that tell the computer to perform a specific action. For example, if you want to add two numbers, compare two values, or check a condition, you use operators.
Therefore, understanding operators in JavaScript is very important because they help you perform calculations, assign values, and control logic in your programs. In this article, we will explain all types of operators in JavaScript with simple examples and clear output, so that you can understand easily.
What Are Operators in JavaScript?
In simple words, operators are special symbols that perform operations on variables and values. For instance, the + symbol adds two numbers, while == compares two values.
Let us take a small example –
let a = 5;
let b = 3;
let sum = a + b;
console.log(sum);
Output:
8
Here, the + operator adds the values of a and b. So basically, operators help us perform actions inside our code.
Types of Operators in JavaScript
Now, let us understand the different types of operators in JavaScript one by one. Moreover, we will explain each type with simple examples.
1. Arithmetic Operators
Arithmetic operators are used to perform mathematical calculations. In other words, they help you add, subtract, multiply, or divide numbers.
Common Arithmetic Operators:
| Operator | Description |
| + | Addition |
| – | Subtraction |
| * | Multiplication |
| / | Division |
| % | Modulus (remainder) |
| ++ | Increment |
| — | Decrement |
Example:
let x = 10;
let y = 5;
console.log(x + y); // Addition
console.log(x - y); // Subtraction
console.log(x * y); // Multiplication
console.log(x / y); // Division
console.log(x % y); // Modulus
Output:
15
5
50
2
0
As you can see, arithmetic operators are mainly used when dealing with numbers.
2. Assignment Operators
Assignment operators are used to assign values to variables. For example, the = operator assigns a value.
However, there are also shortcut assignment operators.
Common Assignment Operators:
| Operator | Example | Meaning |
| = | x = 10 | Assign value |
| += | x += 5 | x = x + 5 |
| -= | x -= 5 | x = x – 5 |
| *= | x *= 2 | x = x * 2 |
| /= | x /= 2 | x = x / 2 |
Example:
let num = 10;
num += 5;
console.log(num);
Output:
15
Therefore, assignment operators help us update values easily.
3. Comparison Operators
Comparison operators compare two values and return either true or false. So basically, they are used in decision-making.
Common Comparison Operators:
| Operator | Description |
| == | Equal to (value only) |
| === | Strict equal (value + type) |
| != | Not equal |
| > | Greater than |
| < | Less than |
| >= | Greater than or equal |
| <= | Less than or equal |
Example:
let a = 10;
let b = "10";
console.log(a == b);
console.log(a === b);
Output:
true
false
Here, == checks only value, while === checks both value and type. That is why the second result is false. Please note this point, this is very important for JS interviews.
4. Logical Operators
Logical operators are used to combine conditions. In other words, they are mostly used inside if statements.
Common Logical Operators:
| Operator | Meaning |
| && | AND |
| ` | |
| ! | NOT |
Example:
let age = 20;
let hasID = true;
console.log(age > 18 && hasID);
Output:
true
Because both conditions are true, the result is true. Therefore, logical operators help us check multiple conditions at once.
5. String Operators
In JavaScript, the + operator is also used to join strings. This process is called concatenation.
Example:
let firstName = "John";
let lastName = "Doe";
console.log(firstName + " " + lastName);
Output:
John Doe
So, besides addition, the + operator can also combine text.
6. Bitwise Operators
Bitwise operators work on binary numbers (0 and 1). However, beginners usually do not use them much.
Some bitwise operators include:
- & (AND)
- | (OR)
- ^ (XOR)
- ~ (NOT)
These operators are mostly used in advanced programming tasks.
7. Conditional (Ternary) Operator
The ternary operator is a shortcut for if…else statements. Therefore, it makes the code shorter and cleaner.
Syntax:
condition ? value1 : value2
Example:
let marks = 75;
let result = (marks > 40) ? "Pass" : "Fail";
console.log(result);
Output:
Pass
So, if the condition is true, it returns the first value; otherwise, it returns the second value.
8. Type Operators
Type operators are used to check the type of a variable.
Example of typeof:
let name = "Rahul";
console.log(typeof name);
Output:
string
Thus, the typeof operator helps us understand what kind of data we are working with.
9. Unary Operators
Unary operators work with only one operand. For example, increment (++) and decrement (–) are unary operators.
Example:
let count = 5;
count++;
console.log(count);
Output:
6
Hence, unary operators perform operations on a single variable.
Why Operators in JavaScript Are Important
Operators are the backbone of JavaScript logic. Without operators, you cannot perform calculations, comparisons, or decision-making.
For example:
- E-commerce websites use operators to calculate discounts.
- Login systems use comparison operators to check passwords.
- Forms use logical operators to validate inputs.
Therefore, mastering operators in JavaScript is essential for becoming a good developer.
Bottom Line
To sum up, operators in JavaScript allow us to perform different actions on values and variables. We learned about arithmetic, assignment, comparison, logical, string, bitwise, conditional, type, and unary operators.
Moreover, we also saw simple examples with clear outputs, which makes understanding easier. If you practice these operators regularly, you will become more confident in writing JavaScript code.
Read Also –
1- Data Types in JavaScript
2- Function in JavaScript
3- Objects in JavaScript
