In JavaScript, operators are special symbols or keywords used to perform operations on values and variables. They allow us to manipulate data, perform calculations, compare values, and combine conditions in our programs.

Operators usually work with operands (the values or variables on which the operation is performed) and produce a result.

For example:

let a = 10;
let b = 5;

let sum = a + b;   // 15

In this example:

• + is the operator

• a and b are operands

• The operator performs addition and returns the result 15.

Another example:

let x = 8;
let y = 3;

let result = x * y;   // 24

Here:

• * is the multiplication operator

• It multiplies x and y and gives the result 24.

Operators can also be used to compare values:

let age = 18;

console.log(age >= 18);  // true

In this example:

• >= checks whether age is greater than or equal to 18

• The result is a boolean value (true or false).

Operators are an essential part of programming because they allow developers to perform calculations, make decisions, and control how data is processed inside a program.

2. Arithmetic Operators (+, -, *, /, %)

Arithmetic operators in JavaScript are used to perform basic mathematical calculations such as addition, subtraction, multiplication, division, and finding the remainder of a division.

Below are the main arithmetic operators:

1. Addition (+)
The addition operator is used to add two numbers.

let a = 10;
let b = 5;

let result = a + b;
console.log(result); // 15

2. Subtraction (-)

The subtraction operator is used to subtract one number from another.

let a = 10;
let b = 5;

let result = a - b;
console.log(result); // 5

3. Multiplication (*)

The multiplication operator multiplies two numbers.

let a = 10;
let b = 5;

let result = a * b;
console.log(result); // 50

4. Division (/)

The division operator divides one number by another.

let a = 10;
let b = 5;

let result = a / b;
console.log(result); // 2

5. Modulus (%)

The modulus operator returns the remainder after division.

let a = 10;
let b = 3;

let result = a % b;
console.log(result); // 1

These arithmetic operators are commonly used in programs when performing calculations, working with numbers, or building logical operations that involve numeric values.

3. Comparison Operators (==, ===, !=, >, <)

Comparison operators in JavaScript are used to compare two values. The result of a comparison is always a boolean value, which means it returns either true or false.

These operators are commonly used in conditions such as if statements and logical checks.

1. Equal to (==)
The == operator checks whether two values are equal. It compares the values but may convert the data type if they are different.

let a = 5;
let b = "5";

console.log(a == b); // true

Here, the result is true because the string "5" is converted to the number 5 before comparison.

2. Strict Equal to (===)

The === operator checks both value and data type. It does not perform type conversion.

let a = 5;
let b = "5";

console.log(a === b); // false

The result is false because a is a number and b is a string.

3. Not Equal to (!=)

The != operator checks whether two values are not equal.

let a = 10;
let b = 5;

console.log(a != b); // true

Since the values are different, the result is true.

4. Greater Than (>)

The > operator checks if the value on the left is greater than the value on the right.

let a = 10;
let b = 5;

console.log(a > b); // true

5. Less Than (<)

The < operator checks if the value on the left is less than the value on the right.

let a = 3;
let b = 7;

console.log(a < b); // true

These comparison operators help programmers make decisions in programs by comparing values and controlling the flow of execution.

4. Logical Operators (&&, ||, !)

Logical operators in JavaScript are used to combine or modify boolean expressions. They are commonly used when working with conditions to check multiple rules at the same time.

The result of logical operations is always a boolean value (true or false).

1. Logical AND (&&)
The && operator returns true only when both conditions are true. If any condition is false, the result becomes false.

let age = 20;
let hasID = true;

console.log(age >= 18 && hasID); // true

In this example, both conditions are true, so the final result is true.

2. Logical OR (||)

The || operator returns true if at least one condition is true.

let isStudent = false;
let hasCoupon = true;

console.log(isStudent || hasCoupon); // true

Here, even though isStudent is false, hasCoupon is true, so the result becomes true.

3. Logical NOT (!)

The ! operator reverses the boolean value. It changes true to false and false to true.

let isLoggedIn = false;

console.log(!isLoggedIn); // true

Since isLoggedIn is false, using ! changes it to true.

Logical operators are useful when multiple conditions need to be checked together while making decisions in a program.

5. Assignment Operators (=, +=, -=)

Assignment operators in JavaScript are used to assign values to variables. They can also update the value of a variable by performing a calculation and assigning the new result back to the variable.

1. Assignment Operator (=)
The = operator is used to assign a value to a variable.

let a = 10;

In this example, the value 10 is assigned to the variable a.

2. Addition Assignment (+=)

The += operator adds a value to the current value of a variable and then assigns the result back to the same variable.

let a = 10;

a += 5;

console.log(a); // 15

This is similar to writing:

a = a + 5;

3. Subtraction Assignment (-=)

The -= operator subtracts a value from the current value of a variable and assigns the result back to the variable.

let a = 10;

a -= 3;

console.log(a); // 7

This is similar to writing:

a = a - 3;

Assignment operators help simplify code and make it easier to update variable values during program execution.

Diagram

1. Operator categories table

2. Truth table for logical operators