Javascript Operators

Arithmetic Operators

Arithmetic operators are used to perform mathematical operations on numbers. These include addition, subtraction, multiplication, and division. Here’s a useful table to summarize the common arithmetic operators:

let a = 5;let b = 3;console.log(a + b); // Output: 8console.log(a * b); // Output: 15

Comparison Operators

Comparison operators are crucial for comparing two values. They return a boolean value, either true or false. Some examples of comparison operators are listed below:

• ==: Equal to
• ===: Strict equal, considers data type
• !=: Not equal to
• !==: Strict not equal
• >: Greater than
• <: Less than
• >=: Greater than or equal to
• <=: Less than or equal to

let x = 10;let y = '10';console.log(x == y);   // Output: trueconsole.log(x === y);  // Output: false

Logical Operators

Logical operators are used to combine multiple conditions. They are often used in conjunction with comparison operators to build complex logical expressions. Here are the main types:

• &&: Logical AND
• ||: Logical OR
• !: Logical NOT

let rain = true;let snow = false;console.log(rain && snow); // Output: falseconsole.log(rain || snow); // Output: trueconsole.log(!rain);        // Output: false

Examples of Javascript Operators

In this section, you will explore various examples of JavaScript operators that are foundational to performing computations and data manipulation in your scripts. Understanding these examples will help you comprehend how different operators are utilized in different situations.

Assignment Operators

Assignment operators are used to assign values to variables. The most basic assignment operator is the equal sign (=), which assigns the value on the right to the variable on the left. Here are some more assignment operators:

• +=: Adds a value to a variable
• -=: Subtracts a value from a variable
• *=: Multiplies a variable by a value
• /=: Divides a variable by a value

let num = 10;num += 5;   // num is now 15num -= 2;   // num is now 13

Ternary Operator

The ternary operator is a shorthand way of writing conditional statements. It is the only JavaScript operator that takes three operands: a condition, an expression if the condition is true, and an expression if the condition is false. This is how it looks:

let age = 20;let canVote = (age >= 18) ? 'Yes' : 'No';// canVote is 'Yes'

Bitwise Operators

Bitwise operators perform operations on binary representations of numbers. Here are the basic bitwise operators you will encounter:

• &: AND
• |: OR
• ^: XOR
• ~: NOT
• <<: Left Shift
• >>: Right Shift

let a = 5; // Binary: 0101let b = 3; // Binary: 0011console.log(a & b); // Output: 1 (0101 & 0011 = 0001)console.log(a | b); // Output: 7 (0101 | 0011 = 0111)

Javascript Spread Operator Explained

The spread operator, introduced in ES6, is a powerful feature in JavaScript that allows you to expand elements of iterables such as arrays, strings, and objects. This operator can make your code more concise and readable by replacing old practices, such as using functions like concat and apply, with simpler syntax.

Using the Spread Operator with Arrays

The spread operator can make it easy to copy arrays or concatenate multiple arrays. Previously, adding arrays together would require the concat method. Now, the spread operator simplifies this process.Example of concatenating arrays:

let arr1 = [1, 2, 3];let arr2 = [4, 5, 6];let combined = [...arr1, ...arr2];// Combined array is [1, 2, 3, 4, 5, 6]

It can also be used to create a shallow copy of an array, making it useful when you want to duplicate data without mutating the original.

Spreading with Objects

In addition to arrays, the spread operator can be utilized with objects to clone properties or add new properties with ease. This is particularly helpful when you want to create new objects based on existing ones with some modifications.

let obj1 = {a: 1, b: 2};let obj2 = {...obj1, c: 3}; // Result will be {a: 1, b: 2, c: 3}

Spread Operator in Function Arguments

Using the spread operator in function calls improves readability and flexibility. It allows you to pass elements of an array as separate arguments instead of using the apply method. Previously, calling a function with an array looked like this:

function sum(a, b, c) {  return a + b + c;}let numbers = [1, 2, 3];console.log(sum.apply(null, numbers)); // Old method

With the spread operator, it becomes more direct and less verbose:

console.log(sum(...numbers)); // New method using spread

Ternary Operator Javascript

The ternary operator is a succinct JavaScript feature used for making quick decisions in your code. It allows you to write a conditional statement in a compact form, which can often replace if-else structures with a single line of code. This operator helps make your scripts more concise and easy to read.

let isMember = true;let discount = isMember ? 0.1 : 0;console.log(discount); // Output: 0.1 if isMember is true, else 0

Understanding Javascript Logical Operators

Logical operators in JavaScript are critical for evaluating conditions that involve multiple criteria. They help you chain together comparison operators to express more complex conditions in a succinct format.Here are the principal logical operators:

• &&: Logical AND - Returns true if both operands are true
• ||: Logical OR - Returns true if at least one operand is true
• !: Logical NOT - Inverts the truth value of the operand

let hasID = true;let isAdult = false;if (hasID && isAdult) {  console.log('Can enter club');} else {  console.log('Entry denied.');}

Javascript Operator Techniques

Mastering different JavaScript operators can provide more control and precision in your coding endeavours. Here are some techniques that leverage these operators effectively:- **Using Compound Assignment:** Quickly update a variable by combining operators, such as += or *=.- **Short-Circuit Evaluation:** Harness this technique in logical operators to optimize conditions without unnecessary evaluations.- **Nullish Coalescing Operator (??):** A newer addition lets you provide default values for null or undefined variables.

let count = 10;count += 5;   // count is now 15let name;let defaultName = name ?? 'Guest'; // defaultName is 'Guest'