Operators in JavaScript

Understanding Operators in JavaScript

Operators are fundamental tools used in JavaScript to perform operations on variables and values. These operations can involve mathematical calculations, comparisons, logical operations, and more. Operators are essential to writing expressive and functional JavaScript code.

In this module, we’ll explore the different types of operators in JavaScript, how they work, and provide examples for each type.

Table of Contents

1. Arithmetic Operators
2. Assignment Operators
3. Comparison Operators
4. Logical Operators
5. Bitwise Operators
6. Conditional (Ternary) Operator
7. String Operators
8. Type Operators
9. Conclusion

1. Arithmetic Operators

Arithmetic operators are used to perform mathematical calculations like addition, subtraction, multiplication, and division. JavaScript supports the following arithmetic operators:

Addition (+)

The + operator adds two numbers or concatenates two strings.

let sum = 10 + 5;
console.log(sum); // Outputs: 15

let greeting = "Hello, " + "world!";
console.log(greeting); // Outputs: Hello, world!

Subtraction (-)

The - operator subtracts the second operand from the first.

let difference = 10 - 5;
console.log(difference); // Outputs: 5

Multiplication (*)

The * operator multiplies two numbers.

let product = 10 * 5;
console.log(product); // Outputs: 50

Division (/)

The / operator divides the first operand by the second.

let quotient = 10 / 2;
console.log(quotient); // Outputs: 5

Modulus (%)

The % operator returns the remainder of a division operation.

let remainder = 10 % 3;
console.log(remainder); // Outputs: 1

Exponentiation () [ES6+]**

The ** operator raises the first operand to the power of the second.

let power = 2 ** 3;
console.log(power); // Outputs: 8

2. Assignment Operators

Assignment operators are used to assign values to variables. The most basic assignment operator is the = operator, but JavaScript provides several shorthand assignment operators for more complex operations.

Basic Assignment (=)

let x = 10;
console.log(x); // Outputs: 10

Add and Assign (+=)

let x = 5;
x += 3;  // Equivalent to x = x + 3;
console.log(x); // Outputs: 8

Subtract and Assign (-=)

let x = 5;
x -= 3;  // Equivalent to x = x - 3;
console.log(x); // Outputs: 2

Multiply and Assign (*=)

let x = 5;
x *= 3;  // Equivalent to x = x * 3;
console.log(x); // Outputs: 15

Divide and Assign (/=)

let x = 10;
x /= 2;  // Equivalent to x = x / 2;
console.log(x); // Outputs: 5

Modulus and Assign (%=)

let x = 10;
x %= 3;  // Equivalent to x = x % 3;
console.log(x); // Outputs: 1

3. Comparison Operators

Comparison operators are used to compare two values and return a Boolean value (true or false).

Equal to (==)

The == operator checks if two values are equal, ignoring their data types.

let x = 5;
let y = "5";
console.log(x == y); // Outputs: true (because "5" is converted to a number)

Strict Equal to (===)

The === operator checks if two values are equal and of the same type.

let x = 5;
let y = "5";
console.log(x === y); // Outputs: false (because one is a number and the other is a string)

Not Equal to (!=)

The != operator checks if two values are not equal, ignoring their data types.

let x = 5;
let y = "5";
console.log(x != y); // Outputs: false (because "5" is converted to a number)

Strict Not Equal to (!==)

The !== operator checks if two values are not equal or not of the same type.

let x = 5;
let y = "5";
console.log(x !== y); // Outputs: true (because one is a number and the other is a string)

Greater than (>)

let x = 10;
let y = 5;
console.log(x > y); // Outputs: true

Less than (<)

let x = 5;
let y = 10;
console.log(x < y); // Outputs: true

Greater than or Equal to (>=)

let x = 10;
let y = 5;
console.log(x >= y); // Outputs: true

Less than or Equal to (<=)

let x = 5;
let y = 10;
console.log(x <= y); // Outputs: true

4. Logical Operators

Logical operators are used to combine or invert Boolean values. These operators are essential for decision-making in JavaScript programs.

AND (&&)

The && operator returns true if both operands are true.

let x = true;
let y = false;
console.log(x && y); // Outputs: false

OR (||)

The || operator returns true if at least one of the operands is true.

let x = true;
let y = false;
console.log(x || y); // Outputs: true

NOT (!)

The ! operator inverts the Boolean value.

let x = true;
console.log(!x); // Outputs: false

5. Bitwise Operators

Bitwise operators work on 32-bit binary numbers and perform bit-level operations. They are not commonly used in most JavaScript programs but can be useful for tasks like manipulating data at the binary level.

AND (&)

let x = 5;  // 0101 in binary
let y = 3;  // 0011 in binary
console.log(x & y); // Outputs: 1 (0001 in binary)

OR (|)

let x = 5;  // 0101 in binary
let y = 3;  // 0011 in binary
console.log(x | y); // Outputs: 7 (0111 in binary)

XOR (^)

let x = 5;  // 0101 in binary
let y = 3;  // 0011 in binary
console.log(x ^ y); // Outputs: 6 (0110 in binary)

6. Conditional (Ternary) Operator

The ternary operator is a shorthand for the if-else statement. It is used to assign a value based on a condition.

let age = 18;
let status = age >= 18 ? "Adult" : "Minor";
console.log(status); // Outputs: Adult

7. String Operators

JavaScript also allows the use of operators with strings, the most common being the concatenation operator.

Concatenation (+)

The + operator is used to concatenate two or more strings.

let greeting = "Hello, " + "world!";
console.log(greeting); // Outputs: Hello, world!

8. Type Operators

The typeof operator returns a string that indicates the type of a variable or expression.

let x = 10;
console.log(typeof x); // Outputs: number

The instanceof operator checks if an object is an instance of a specific class or constructor function.

let x = [1, 2, 3];
console.log(x instanceof Array); // Outputs: true

9. Conclusion

Operators are essential tools in JavaScript for performing various tasks, from mathematical calculations to logical comparisons. In this module, we covered the key operators in JavaScript, including arithmetic operators, assignment operators, comparison operators, and more. Mastering these operators will enable you to write efficient, expressive, and powerful JavaScript code.