Arithmetic Operators in JavaScript

• Arithmetic operators are symbols or keywords used to perform mathematical calculations and operations on numerical values
• They allow the computer to perform addition, subtraction, multiplication, division, and more

Addition operator (+)

• The addition operator (+) is used to add numerical values together or concatenate strings:

const sum = 5 + 3;
const fullName = 'John' + ' ' + 'Doe';

• In this example, the addition operator adds the values 5 and 3, resulting in 8
• It also concatenates the strings 'John', ' ', and 'Doe' to form the full name 'John Doe'

Subtraction operator (-)

• The subtraction operator (-) is used to subtract one numerical value from another:

const difference = 10 - 4;

• In this example, the subtraction operator subtracts the value 4 from 10, resulting in 6

Multiplication operator (*)

• The multiplication operator (*) is used to multiply numerical values together:

const product = 3 * 5;

• In this example, the multiplication operator multiplies the values 3 and 5, resulting in 15

Exponentiation operator (**)

• The exponentiation operator (**) is used to multiply numerical values by the power of another number:

const product = 3 ** 3;

• In this example, the exponentiation operator multiplies the value 3 to the power 3, resulting in 27

The division operator (/)

• The division operator (/) is used to divide one numerical value by another:

const quotient = 10 / 2;

• In this example, the division operator divides the value 10 by 2, resulting in 5

The modulus operator (%)

• The modulus operator (%) returns the remainder when one numerical value is divided by another:

const remainder = 10 % 3;

• In this example, the modulus operator divides the value 10 by 3 and returns the remainder, which is 1

Increment operator (++) & decrement operator (—)

• The increment operator (++) and decrement operator (--) are used to increase or decrease the value of a numerical variable by one:

let counter = 5;
counter++;
counter--;

• In this example, the increment operator increases the value of counter by one, resulting in 6
• The decrement operator decreases it back to 5

Operator precedence (BIDMAS / BODMAS)

• Arithmetic operators follow the rules of operator precedence, which determine the order in which operators are evaluated
• Parentheses () can be used to control the order of evaluation:

const result = 2 + 3 * 4;
const adjustedResult = (2 + 3) * 4;

• In the first example, without parentheses, the multiplication (*) is performed before the addition (+), resulting in 14
• In the second example, with parentheses, the addition is evaluated first, resulting in 5, which is then multiplied by 4, resulting in 20

Logical Operators in JavaScript

• Logical or comparison operators are symbols or keywords used to compare values and return a boolean result
• They allow a comparison of variables, or expressions to determine relationships, equality, or inequality between them.

Equal to (==) operator

• The equal to the operator (==) compares two values and returns true if they are equal, and false otherwise
• It performs type coercion, meaning it converts the operands to a common type before comparing them:

const x = 5;
const y = '5';
 
console.log(x == y);

• In this example, the equal to operator compares the value 5 (a number) with the value '5' (a string). Since JavaScript performs type coercion, the operands are considered equal, resulting in true

Not equal to (!=) operator

• The not equal to the operator (!=) compares two values and returns true if they are not equal, and false if they are equal
• Like the equal to operator, it performs type coercion:

const x = 5;
const y = '5';
 
console.log(x != y);

• In this example, the not equal to operator compares the value 5 with the value '5'. Since JavaScript performs type coercion and considers the operands equal, the result is false

Strict equal to (===) operator

The strict equal to the operator (===) compares two values and returns true if they are equal in both value and type. Unlike the equal to operator, it does not perform type coercion:

const x = 5;
const y = '5';
 
console.log(x === y);

• In this example, the strict equal to operator compares the value 5 with the value '5'. Since the operands have different types, the result is false

Strict not equal to (!==) operator

• The strict is not equal to the operator (!==) compares two values and returns true if they are not equal in either value or type
• It does not perform type coercion:

const x = 5;
const y = '5';
 
console.log(x !== y);

• In this example, the strict not equal to the operator compares the value 5 with the value '5'. Since the operands have different types, the result is true

Greater than (>) & less than (<) operators

• The greater than the operator (>) **compares two values and returns true if the left operand is greater than the right operand
• The less than operator (<) returns true if the left operand is less than the right operand:

const x = 5;
const y = 10;
 
console.log(x > y);
console.log(x < y);

• In this example, the greater than operator compares the value 5 with the value 10, resulting in false
• The less than operator compares 5 with 10, resulting in true

Greater than or equal to (>=) & less than or equal to (⇐) operators

• The greater than or equal to the operator (>=) compares two values and returns true if the left operand is greater than or equal to the right operand
• The less than or equal to the operator (<=) returns true if the left operand is less than or equal to the right operand:

const x = 5;
const y = 10;
 
console.log(x >= y);
console.log(x <= y);

• In this example, the greater than or equal operator compares 5 with 10, resulting in false
• The less than or equal to operator compares 5 with 10, resulting in true

Boolean Operators in JavaScript

• Boolean operators are symbols or keywords used to combine and manipulate boolean values
• They allow the computer to perform logical operations, such as combining conditions, negating values, and determining whether an expression is true or false.

AND operator (&&)

• The AND operator (&&) returns true if both operands are true, otherwise returns false:

const x = 5;
const y = 10;
const z = 15;
 
const result = (x < y) && (y < z);

• In this example, the expression (x < y) && (y < z) evaluates to true because both conditions are true. If any of the conditions were false, the result would be false

OR operator (||)

• The OR operator (||) returns true if at least one of the operands is true, and false if both operands are false:

const a = 5;
const b = 10;
const c = 15;
 
const result = (a > b) || (b < c);

• In this example, the expression (a > b) || (b < c) evaluates to true because the second condition is true, even though the first condition is false. If both conditions were false, the result would be false

NOT operator (!)

• The NOT operator (!) is used to negate a Boolean value. It returns true if the operand is false, and false if the operand is true:

const value = false;
 
const result = !value;

• In this example, the ! operator negates the value of false, resulting in true