1.5 Understanding Operators in JavaScript

Operators in JavaScript are symbols that are used to perform operations on operands (values or variables). They are the foundation of any programming language, enabling developers to execute mathematical calculations, compare values, assign values, and perform logical operations, among other tasks. JavaScript offers a rich set of operators, and understanding how they work is crucial for writing effective and efficient code. Here is an overview of the different types of operators in JavaScript and how to use them.

Arithmetic Operators

Arithmetic operators are used to perform simple mathematical operations. JavaScript supports the following arithmetic operators:

• Addition (+): Adds two operands.
• Subtraction (-): Subtracts the second operand from the first.
• Multiplication (*): Multiplies two operands.
• Division (/): Divides the first operand by the second.
• Modulus (%): Returns the remainder of dividing the first operand by the second.
• Increment (++): Increases an integer value by one.
• Decrement (--): Decreases an integer value by one.

let a = 10, b = 5;
console.log(a + b); // 15
console.log(a - b); // 5
console.log(a * b); // 50
console.log(a / b); // 2
console.log(a % b); // 0

Comparison Operators

Comparison operators compare two values and return a Boolean value, either true or false, based on whether the comparison is true.

• Equal (==): Checks if the values of two operands are equal (after type conversion).
• Strict equal (===): Checks if the values and types of two operands are equal.
• Not equal (!=): Checks if the values of two operands are not equal.
• Strict not equal (!==): Checks if the values and types of two operands are not equal.
• Greater than (>): Checks if the value of the left operand is greater than the value of the right operand.
• Less than (<): Checks if the value of the left operand is less than the value of the right operand.
• Greater than or equal to (>=): Checks if the value of the left operand is greater than or equal to the value of the right operand.
• Less than or equal to (<=): Checks if the value of the left operand is less than or equal to the value of the right operand.

let c = 10, d = "10";
console.log(c == d); // true
console.log(c === d); // false
console.log(c != d); // false
console.log(c !== d); // true

Logical Operators

Logical operators are used to determine the logic between variables or values. They are primarily used in conditional statements.

• Logical AND (&&): Returns true if both operands are true.
• Logical OR (||): Returns true if at least one of the operands is true.
• Logical NOT (!): Returns true if the operand is false and vice versa.

let e = true, f = false;
console.log(e && f); // false
console.log(e || f); // true
console.log(!e); // false

Assignment Operators

Assignment operators assign values to JavaScript variables.

• Assignment (=): Assigns the value of the right operand to the left operand.
• Add and assign (+=): Adds the right operand to the left operand and assigns the result to the left operand.
• Subtract and assign (-=): Subtracts the right operand from the left operand and assigns the result to the left operand.
• Multiply and assign (*=): Multiplies the right operand with the left operand and assigns the result to the left operand.
• Divide and assign (/=): Divides the left operand by the right operand and assigns the result to the left operand.

let g = 10;
g += 5; // g is now 15
g -= 5; // g is now 10
g *= 5; // g is now 50
g /= 5; // g is now 10

Other Operators

JavaScript also includes other operators such as the ternary operator (a conditional operator that assigns a value to a variable based on some condition), the typeof operator (which returns the type of a variable or expression), and the delete operator (which deletes an object's property).

Understanding and effectively utilizing the various operators in JavaScript is essential for controlling program flow, performing calculations, and manipulating data. Mastery of operators enables developers to write concise, efficient, and readable code, laying the groundwork for more advanced programming concepts and techniques.