DEV Community: Madhan Raj

JavaScript Array Iterations

Madhan Raj — Wed, 24 Jun 2026 06:57:19 +0000

JavaScript Array Iterations

Array Iteration Methods
Array iteration methods operate on every array item.

Array forEach
Array map()
Array flatMap()
Array filter()
Array reduce()
Array reduceRight()
Array every()
Array some()
Array from()
Array keys()
Array entries()
Array with()
Array Spread (...)
Array Rest (...)

JavaScript Array forEach()

The forEach() method calls a function (a callback function) once for each array element.
Example

const numbers = [45, 4, 9, 16, 25];
let txt = "";
numbers.forEach(myFunction);

function myFunction(value, index, array) {
  txt += value + "<br>";
}

Note that the function takes 3 arguments:

The item value
The item index
The array itself

The example above uses only the value parameter. The example can be rewritten to:
Example

const numbers = [45, 4, 9, 16, 25];
let txt = "";
numbers.forEach(myFunction);

function myFunction(value) {
  txt += value + "<br>";
}

JavaScript Array map()

The map() method creates a new array by performing a function on each array element.

The map() method does not execute the function for array elements without values.

The map() method does not change the original array.

This example multiplies each array value by 2:
Example

const numbers1 = [45, 4, 9, 16, 25];
const numbers2 = numbers1.map(myFunction);

function myFunction(value, index, array) {
  return value * 2;
}

Note that the function takes 3 arguments:

The item value
The item index
The array itself

When a callback function uses only the value parameter, the index and array parameters can be omitted:
Example

const numbers1 = [45, 4, 9, 16, 25];
const numbers2 = numbers1.map(myFunction);

function myFunction(value) {
  return value * 2;
}

JavaScript Array flatMap()

ES2019 added the Array flatMap() method to JavaScript.

The flatMap() method first maps all elements of an array and then creates a new array by flattening the array.
Example

const myArr = [1, 2, 3, 4, 5, 6];
const newArr = myArr.flatMap(x => [x, x * 10]);

JavaScript Array filter()

The filter() method creates a new array with array elements that pass a test.

This example creates a new array from elements with a value larger than 18:
Example

const numbers = [45, 4, 9, 16, 25];
const over18 = numbers.filter(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

JavaScript Array reduce()

The reduce() method runs a function on each array element to produce a single value.

The reduce() method works from left-to-right in the array. See also reduceRight().

The reduce() method does not reduce the original array.

This example finds the sum of all numbers in an array:
Example

const numbers = [45, 4, 9, 16, 25];
let sum = numbers.reduce(myFunction);

function myFunction(total, value, index, array) {
  return total + value;
}

Note that the function takes 4 arguments:

The total (the initial value / previously returned value)
The item value
The item index
The array itself

Since the example above does not use the index and array parameters, it can be rewritten to:
Example

const numbers = [45, 4, 9, 16, 25];
let sum = numbers.reduce(myFunction);

function myFunction(total, value) {
  return total + value;
}

JavaScript Array reduceRight()

The reduceRight() method runs a function on each array element to produce a single value.

The reduceRight() works from right-to-left in the array. See also reduce().

The reduceRight() method does not reduce the original array.

This example finds the sum of all numbers in an array:
Example

const numbers = [45, 4, 9, 16, 25];
let sum = numbers.reduceRight(myFunction);

function myFunction(total, value, index, array) {
  return total + value;
}

Note that the function takes 4 arguments:

The total (the initial value / previously returned value)
The item value
The item index
The array itself

The example above does not use the index and array parameters. It can be rewritten to:
Example

const numbers = [45, 4, 9, 16, 25];
let sum = numbers.reduceRight(myFunction);

function myFunction(total, value) {
  return total + value;
}

JavaScript Array every()

The every() method checks if all array values pass a test.

This example checks if all array values are larger than 18:
Example

const numbers = [45, 4, 9, 16, 25];
let allOver18 = numbers.every(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

JavaScript Array some()

The some() method checks if some array values pass a test.

This example checks if some array values are larger than 18:
Example

const numbers = [45, 4, 9, 16, 25];
let someOver18 = numbers.some(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

JavaScript Array.from()

The Array.from() method returns an Array object from:

Any iterable object

Any object with a length property

Example

Create an Array from a String:
let text = "ABCDEFG";
Array.from(text);

JavaScript Array Spread (...)

The ... operator expands an array into individual elements.

This can be used join arrays:
Example 1

const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];

const arr3 = [...arr1, ...arr2];

In the example above, ...arr1 expands arr1 into single elements, ...arr2 expands arr2 into single elements, and arr3 is constructed using ...arr1 and ...arr2.
Example 2

const q1 = ["Jan", "Feb", "Mar"];
const q2 = ["Apr", "May", "Jun"];
const q3 = ["Jul", "Aug", "Sep"];
const q4 = ["Oct", "Nov", "Des"];

const year = [...q1, ...q2, ...q3, ...q4];

The spread operator (...) can be used to copy an array:
Example 3

const arr1 = [1, 2, 3];
const arr2 = [...arr1];

The spread operator (...) can be used to pass arguments to a function:
Example 4

const numbers = [23,55,21,87,56];
let minValue = Math.min(...numbers);
let maxValue = Math.max(...numbers);

Reference
https://www.w3schools.com/js/js_array_iteration.asp

Array Methods In Javascript

Madhan Raj — Mon, 22 Jun 2026 06:32:49 +0000

JavaScript Array Methods

Basic Array Methods

Array length
Array toString()
Array at()
Array join()
Array pop()
Array push()
Array shift()
Array unshift()
Array isArray()
Array delete()
Array concat()
Array copyWithin()
Array flat()
Array slice()
Array splice()
Array toSpliced()

JavaScript Array length
The length property returns the length (size) of an array:
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

let size = fruits.length;

The length property can also be used to set the length of an array:
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.length = 2;

JavaScript Array toString()

The toString() method returns the elements of an array as a comma separated string.
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

let myList = fruits.toString();

Every JavaScript object has a toString() method.

The toString() method is used internally by JavaScript when an object needs to be displayed as a text (like in HTML), or when an object needs to be used as a string.

JavaScript Array at()
ES2022 introduced the array method at():
Examples

Get the third element of fruits using at():
const fruits = ["Banana", "Orange", "Apple", "Mango"];
let fruit = fruits.at(2);

Get the third element of fruits using []:
const fruits = ["Banana", "Orange", "Apple", "Mango"];
let fruit = fruits[2];

JavaScript Array join()

The join() method also joins all array elements into a string.

It behaves just like toString(), but in addition you can specify the separator:
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.join(" * ");

Result:
Banana * Orange * Apple * Mango

Popping and Pushing

When you work with arrays, it is easy to remove elements and add new elements.

This is what popping and pushing is:

Popping items out of an array, or pushing items into an array.

JavaScript Array pop()

The pop() method removes the last element from an array:
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();

The pop() method returns the value that was "popped out":

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
let fruit = fruits.pop();

JavaScript Array push()

The push() method adds a new element to an array (at the end):
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi");

The push() method returns the new array length:
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
let length = fruits.push("Kiwi");

Shifting Elements

Shifting is equivalent to popping, but working on the first element instead of the last.
JavaScript Array shift()
The shift() method removes the first array element and "shifts" all other elements to a lower index.
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift();

The shift() method returns the value that was "shifted out":
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
let fruit = fruits.shift();

JavaScript Array unshift()

The unshift() method adds a new element to an array (at the beginning), and "unshifts" older elements:
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon");

The unshift() method returns the new array length:
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon");

Changing Elements

Array elements are accessed using their index number:

Array indexes start with 0:

[0] is the first array element
[1] is the second
[2] is the third ...
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[0] = "Kiwi";

JavaScript Array length

The length property provides an easy way to append a new element to an array:
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[fruits.length] = "Kiwi";

Reference
https://www.w3schools.com/js/js_array_methods.asp

Arrays in Javascript

Madhan Raj — Fri, 19 Jun 2026 06:00:03 +0000

JavaScript Arrays

An Array is an object type designed for storing data collections.

Key characteristics of JavaScript arrays are:

Elements: An array is a list of values, known as elements.

Ordered: Array elements are ordered based on their index.

Zero indexed: The first element is at index 0, the second at index 1, and so on.

Dynamic size: Arrays can grow or shrink as elements are added or removed.

Heterogeneous: Arrays can store elements of different data types (numbers, strings, objects and other arrays).

Why Use Arrays?

If you have a list of items (a list of car names, for example), storing the names in single variables could look like this:

let car1 = "Saab";
let car2 = "Volvo";
let car3 = "BMW";

However, what if you want to loop through the cars and find a specific one? And what if you had not 3 cars, but 300?

The solution is an array!

An array can hold many values under a single name, and you can access the values by referring to an index number.

Creating an Array

Using an array literal is the easiest way to create a JavaScript Array.

Syntax:

const array_name = [item1, item2, ...];

It is a common practice to declare arrays with the const keyword.

Learn more about const with arrays in the chapter: JS Array Const.

Using the JavaScript Keyword new

The following example also creates an Array, and assigns values to it:
Example

const cars = new Array("Saab", "Volvo", "BMW");

The two examples above do exactly the same.

There is no need to use new Array().

For simplicity, readability and execution speed, use the array literal method.

Arrays are Objects

Arrays are a special type of objects. The type of operator in JavaScript returns "object" for arrays.

But, JavaScript arrays are best described as arrays.

Arrays use numbers to access its "elements". In this example, person[0] returns John:
Array:

const person = ["John", "Doe", 46];

Array Elements Can Be Objects

JavaScript variables can be objects. Arrays are special kinds of objects.

Because of this, you can have variables of different types in the same Array.

You can have objects in an Array. You can have functions in an Array. You can have arrays in an Array:

myArray[0] = Date.now;
myArray[1] = myFunction;
myArray[2] = myCars;

The length Property

The length property of an array returns the length of an array (the number of array elements).
Example
const fruits = ["Banana", "Orange", "Apple", "Mango"];
let length = fruits.length;

The length property is always one more than the highest array index.

Accessing the First Array Element
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
let fruit = fruits[0];

Accessing the Last Array Element
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
let fruit = fruits[fruits.length - 1];

Reference
https://www.w3schools.com/js/js_arrays.asp

Javascript Objects

Madhan Raj — Tue, 16 Jun 2026 06:33:04 +0000

What are JavaScript Objects?

Objects are variables that can store both values and functions.

Values are stored as key:value pairs called properties.

Functions are stored as key:function() pairs called methods.

Real Life Comparison
In real life, we can describe subjects as objects (a car, a person, a house)

Different cars have the same properties, but the property values can differ from car to car.

Different cars have the same methods, but the methods can be performed at different times.

Object Example

This code example assigns many values (Fiat, 500, white) to an object named car:

Example

const car = {
  type: "Fiat",
  model: "500",
  color: "white"
};

type, model, and color are properties

"Fiat", "500", and "white" are property values

Object Literal

An object literal "literally" describes an object using a concise syntax with zero or more key:value pairs inside curly braces to describe all the object properties:

{firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"}

How to Create a JavaScript Object

An object literal is the simplest and most common way to define a JavaScript object.

All the examples below, create the same JavaScript object:
Example 1

// Create an Object
const person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};

Spaces and line breaks are not important. An object literal can span multiple lines:
Example 2

// Create an Object
const person = {
  firstName: "John",
  lastName: "Doe",
  age: 50,
  eyeColor: "blue"
};

JavaScript Object Properties

Properties are key:value Pairs

A JavaScript object is a collection of properties

Properties can be changed, added, and deleted.

Accessing JavaScript Properties

You can access object properties in these ways:

Dot notation
Bracket notation
Expression

Examples

// objectName.property
let age = person.age;
//objectName["property"]
let age = person["age"];
//objectName[expression]
let age = person[x];

Dot Notation

objectName.propertyName
person.firstname + " is " + person.age;

In general, dot notation is preferred for readability and simplicity.

Bracket notation is necessary in some cases:

The property name is stored in a variable:
person[myVariable]
The property name is not a valid identifier:
person["last-name"]

JavaScript Object Methods

What are Object Methods?

Methods are actions that can be performed on objects.

Methods are functions stored as property values.

Example

const person = {
  firstName: "John",
  lastName: "Doe",
  age: 50,
  fullName: function() {
    return this.firstName + " " + this.lastName;
  }
};

![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vgpugduoi8g8z9bouoot.png)

Reference
https://www.w3schools.com/js/js_object_methods.asp

Functions in Javascript

Madhan Raj — Mon, 15 Jun 2026 05:57:00 +0000

*Type of Functions *

Here the main types of functions in JavaScript:

1. Named Function
A function that has its own name when declared. It’s easy to reuse and debug because the name shows up in error messages or stack traces.

function greet() {
  return "Hello!";
}
console.log(greet());

2. Anonymous Function
A function that does not have a name. It is usually assigned to a variable or used as a callback. Since it has no name, it cannot be called directly.

const greet = function() {
  return "Hi there!";
};
console.log(greet());

3. Function Expression
When you assign a function (can be named or anonymous) to a variable. The function can then be used by calling that variable.

const add = function(a, b) {
  return a + b;
};
console.log(add(2, 3));

4. Arrow Function (ES6)

A new way to write functions using the => syntax. They are shorter and do not have their own this binding, which makes them useful in some cases.

const square = n => n * n;
console.log(square(4));

5. Immediately Invoked Function Expression (IIFE)
IIFE functions are executed immediately after their definition. They are often used to create isolated scopes.

(function () {
    console.log("This runs immediately!");
})();

6. Async Function
Functions that handle asynchronous tasks. Declared with async, they return a Promise, and you can use await inside them to pause until another Promise resolves.

async function fetchData() {
  return "Data fetched!";
}
fetchData().then(console.log);

7.Pure Functions
Pure functions return the same output for the same inputs and do not produce side effects. They do not modify state outside their scope, such as modifying global variables, changing the state of objects passed as arguments, or performing I/O operations.

function pureAdd(a, b) {
    return a + b;
}

console.log(pureAdd(2, 3));

Callback Functions

Constructor Function

Generator Function
Recursive Function
Higher-Order Function
Nested Functions
Rest Parameter Function
[TBH]

Reference
https://www.geeksforgeeks.org/javascript/functions-in-javascript/

ILUGC MEETUP at IIT Madras

Madhan Raj — Sun, 14 Jun 2026 16:41:04 +0000

ILUGC Meetup-1

Indian Linux Users Group Chennai-ILUGC has arraged a monthly meetup on 2nd Saturday of every Month. By that I have attended the meetup for this june Month which was held in IIT-Madras.

Agenda
The main Agenda of the Meetup is about to have a discussion about the Linux features and how linux is better the other OS.

Highlight of the Event

The participants of the Event are from Various Fields like Developers,Ux designers,app developers,Testers etc and also from different sections like Students,Entreprenurs,IT professions,College Professionals etc. So we had a different kinds of opinions from them which creates the disscussion very interesting.

*The Main Highlight of the Meeting is about how we should aware the monopoly of Microsoft Windows controlling us and how we should'nt rely on one Brand. To avoid from the control of one brand we should encourage and create awareness of the Open sources like Linux.

In that Discussion the participants can also Present their Projects or new initiatives by that One Participant has explained about a open source named **Playwright* and also he demonstrated his project which is used by Playwright and also explained how Playwright is better than Selenium which was quite Interesting and which was new to know.

Feedback of the Participants

 The Organizers has conducted the meeting in very good and engaging way. They made the participants to have a self intro about them, which helps to know about the participants and their field and why they are using Linux and told their Experience about the Linux.

From this Meetup I had a great experience and come to know about a meetup discussion look like and helps to gain knowledge from the peoples from different fields and age groups. This meetup gave me an good experience to attend the future Meetups and also to participate in various meetups.

Basic Functions in Javascript

Madhan Raj — Fri, 12 Jun 2026 06:57:20 +0000

Functions in JavaScript are reusable blocks of code designed to perform specific tasks. They allow you to organize, reuse, and modularize code. It can take inputs, perform actions, and return outputs.

Understanding Functions

In functions, parameters are placeholders defined in the function, while arguments are the actual values you pass when calling the function.
Example:

function greet(name) {   // 'name' is a parameter
  console.log("Hello " + name);
}

greet("Alice");  // "Alice" is the argument

Parameter: name (placeholder inside the function).
Argument: "Alice" (real value given at call time).

Default Parameters
Default parameters are used when no argument is provided during the function call.
If no value is passed, the function automatically uses the default value.

function greet(name = "Guest") {
  console.log("Hello, " + name);
}

greet();
greet("Aman");

Return Statement
The return statement is used to send a result back from a function.
When return executes, the function stops running at that point.
The returned value can be stored in a variable or used directly.

function add(a, b) {
  return a + b; // returns the sum
}

let result = add(5, 10);
console.log(result);

JavaScript Function Parameters

Parameters (Function Input)

Parameters allow you to pass (send) values to a function.

Parameters are listed inside the parentheses in the function definition.
Example

function multiply(a, b) {
  return a * b;
}

let result = multiply(4, 5);

Default Parameter Values
ECMAScript 2015 allows function parameters to have default values.

The default value is used if no argument is provided.
Example
If y is not passed or undefined, then y = 10.

function myFunction(x, y = 10) {
  return x + y;
}
myFunction(5);

Parameters vs. Arguments

In JavaScript, function parameters and arguments are distinct concepts:

Parameters are the names listed in the function definition.

Arguments are the real values passed to, and received by the function.

JavaScript Function Return
A function can return a value back to the code that called it.

The return statement is used to send a value out of a function.
Returning Values from Functions
The return Statement
When a function reaches a return statement, the function stops executing.

The value after the return keyword is sent back to the caller.
Example

function sayHello() {
  return "Hello World";
}

let message = sayHello();

Returning a Calculated Value
Most functions return the result of a calculation or an operation.

Example

function multiply(a, b) {
  return a * b;
}

let result = multiply(4, 5);

Reference
https://www.w3schools.com/js/js_function_arguments.asp

For Loop and Do-While Loop in Javascript

Madhan Raj — Wed, 10 Jun 2026 06:10:02 +0000

JavaScript For Loop

For Loops can execute a block of code a number of times.

For Loops are fundamental for tasks like performing an action multiple times.

The For Loop

The for statement creates a loop with 3 optional expressions:

 for (exp 1; exp 2; exp 3) {
  // code block to be executed
}

exp 1 is executed (one time) before the execution of the code block.

exp 2 defines the condition for executing the code block.

exp 3 is executed (every time) after the code block has been executed.

Example

for (let i = 0; i < 5; i++) {
  text += "The number is " + i + "<br>";
}

Output

JavaScript Loops
The for Loop

BMW
Volvo
Saab
Ford

From the example above, you can read:

exp 1 sets a variable before the loop starts (let i = 0).

exp 2 defines the condition for the loop to run (i must be less than 5).

exp 3 increases a value (i++) after the code block has been executed.

How to use exp 1
exp 1 is used to initialize the variable(s) used in the loop (let i = 0).

exp 1 is optional.

You can omit exp 1 if the value is set before the loop starts:

Example

const cars = ["BMW", "Volvo", "Saab", "Ford"];
let len = cars.length;

let i = 2;

let text = "";
for (; i < len; i++) {
  text += cars[i] + "<br>";
}

How to use exp 2
exp 2 is used to evaluate the condition of the initial variable (i < len).

exp 2 is also optional.

If exp 2 returns false, the loop will end.

If you omit exp 2, you must provide a break inside the loop.

Otherwise the loop will never end.

This will crash your browser.

How to use exp 3

exp 3 increments the value of the initial variable (i++).

exp 3 is optional.

exp 3 can do anything like negative increment (i--), positive increment (i = i + 15), or anything else.

exp 3 can be omitted (if you increment the value inside the loop):

Example

const cars = ["BMW", "Volvo", "Saab", "Ford"];
let len = cars.length;

let i = 0;

let text = "";
for (; i < len; ) {
  text += cars[i] + "<br>";
  i++;
}

Output
JavaScript Loops
The for Loop

BMW
Volvo
Saab
Ford

Loop Scope
Using var in a loop:
Example

 var i = 5;

for (var i = 0; i < 10; i++) {
  // some code
}

// Here i is 10

Output
JavaScript Scope
Loop Scope

JavaScript While Loops

While Loops
While loops execute a block of code as long as a specified condition is true.

JavaScript have two types of while loops:

The while loop
The do while loop

The While Loop

The while loop loops through a block of code as long as a specified condition is true.

Syntax
while (condition) {
// code block to be executed
}

The Do While Loop
The do while loop is a variant of the while loop. This loop will execute the code block once, before checking if the condition is true, then it will repeat the loop as long as the condition is true.

Syntax

do {
  // code block to be executed
}
while (condition);

The do while runs at least once, even if the condition is false from the start.

This is because the code block is executed before the condition is tested:

Example

do {
  text += "The number is " + i;
  i++;
}
while (i < 10);

Output
JavaScript Loops
The do...while Loop

The number is 0
The number is 1
The number is 2
The number is 3
The number is 4
The number is 5
The number is 6
The number is 7
The number is 8
The number is 9

Reference
https://www.w3schools.com/js/js_loop_while.asp

While Looping In Javascript

Madhan Raj — Tue, 09 Jun 2026 05:59:24 +0000

JavaScript Loops

Loops in JavaScript allow a block of code to run multiple times as long as a given condition is satisfied. They help reduce repetition and make programs more efficient and organized.

Loops continue running until the condition becomes false.
They are useful for iterating over arrays, strings, and ranges of values.

1. for Loop
1.1 for in loop
1.2 For each loop
2. while Loop
3. do-while Loop

While Loop
The while loop loops through a block of code as long as a specified condition is true.

While loop starts with the checking of Boolean condition. If it evaluated to true, then the loop body statements are executed otherwise first statement following the loop is executed. For this reason it is also called Entry control loop
Once the condition is evaluated to true, the statements in the loop body are executed. Normally the statements contain an update value for the variable being processed for the next iteration.
When the condition becomes false, the loop terminates which marks the end of its life cycle.

Syntax

 while (condition) {
  // code block to be executed
}

Example

while (i < 10) {
  text += "The number is " + i;
  i++;
}

📝 Basic Example

let count = 0;

while (count < 3) {
  console.log("Count is: " + count);
  count++; // Updates the variable so the condition eventually becomes false
}

output

Count is: 0
Count is: 1
Count is: 2

Conditional Statements in Javascript

Madhan Raj — Thu, 04 Jun 2026 07:18:09 +0000

JavaScript conditional statements are used to make decisions in a program based on given conditions. They control the flow of execution by running different code blocks depending on whether a condition is true or false.

*Conditions are evaluated using comparison and logical operators.
*They help in building dynamic and interactive applications by responding to different inputs.

*Types of Conditional Statements *

1. if Statement
The if statement checks a condition written inside parentheses. If the condition evaluates to true, the code inside {} is executed; otherwise, it is skipped.

*Executes code only when a specified condition is true.
*Useful for making simple decisions in a program.

Syntax:

if (condition) {
  // code runs if condition is true
}

let x = 20;

if (x % 2 === 0) {
    console.log("Even");
}

if (x % 2 !== 0) {
    console.log("Odd");
};

2. if-else Statement

 The if-else statement executes one block of code if a condition is true and another block if it is false. It ensures that exactly one of the two code blocks runs.

*Used when there are two possible outcomes.
*The else block runs when the if condition is not satisfied.

let age = 25;

if (age >= 18) {
    console.log("Adult")
} else {
    console.log("Not an Adult")
};

Output
Adult

3. else if Statement
The else if statement is used to test multiple conditions in sequence. It executes the first block whose condition evaluates to true.

*Allows checking more than two conditions.
*Evaluated from top to bottom until a true condition is found.

const x = 0;

if (x > 0) {
    console.log("Positive.");
} else if (x < 0) {
    console.log("Negative.");
} else {
    console.log("Zero.");
};

Output
Zero

4. Using Switch Statement (JavaScript Switch Case)

The switch statement evaluates an expression and executes the matching case block based on its value. It provides a clean and readable way to handle multiple conditions for a single variable.

*Used when one variable needs to be compared against multiple fixed values.
*Improves readability compared to long if...else if chains.

const marks = 85;

let Branch;

switch (true) {
    case marks >= 90:
        Branch = "Computer science engineering";
        break;
    case marks >= 80:
        Branch = "Mechanical engineering";
        break;
    case marks >= 70:
        Branch = "Chemical engineering";
        break;
    case marks >= 60:
        Branch = "Electronics and communication";
        break;
    case marks >= 50:
        Branch = "Civil engineering";
        break;
    default:
        Branch = "Bio technology";
        break;
}

console.log(`Student Branch name is : ${Branch}`);

output
Student Branch name is : Mechanical engineering

5. Using Ternary Operator ( ?: )
The ternary operator is a compact shorthand for an if...else statement. It is called “ternary” because it takes three operands:

*A condition to test.
*An expression to evaluate if the condition is true.
*An expression to evaluate if the condition is false.[TBD]

Syntax
condition ? expressionIfTrue : expressionIfFalse

let age = 21;

const result =
    (age >= 18) ? "You are eligible to vote."
        : "You are not eligible to vote.";

console.log(result);

output
You are eligible to vote.

SUMMARY

Reasons to Use Conditional Statements

Control Program Flow: Decide which code to execute based on different situations.

Make Decisions: React differently to user input, data values, or system states.

Enhance Interactivity: Enable dynamic behavior in apps and websites.

Handle Multiple Scenarios: Manage different outcomes or error handling paths.

Improve Code Flexibility: Write adaptable, reusable code that can respond to change.

Reference
https://www.geeksforgeeks.org/javascript/conditional-statements-in-javascript/

Operators In Javascript.

Madhan Raj — Wed, 03 Jun 2026 06:31:54 +0000

Types in JavaScript Operators

*JS Arithmetic Operator
*JS Assignement Operator
*JS Relational Operator
*JS Conditional Operator
*JS Comparitional Operator
*JS Logical Operator

Operators are for Mathematical and Logical Computations

The Assignment Operator = assigns values

The Addition Operator + adds values

The Multiplication Operator * multiplies values

The Comparison Operator > compares values

Arithmetic operators perform arithmetic on numbers (literals or variables).

JavaScript Addition
JavaScript Addition

The Addition Operator (+) adds numbers:
Adding

let x = 5;
let y = 2;
let z = x + y;

Subtracting

The subtraction operator (-) subtracts numbers.
Example

let x = 5;
let y = 2;
let z = x - y;

JavaScript Multiplication

The Multiplication Operator () multiplies numbers:
**Multiplying*

let x = 5;
let y = 2;
let z = x * y;

Dividing

The division operator (/) divides numbers.
Example

let x = 5;
let y = 2;
let z = x / y;

JavaScript Assignment Operators
Assignment operators assign values to JavaScript variables.

Given that x = 10 and y = 5, the table below explains the assignment operators:

Logical Assignment Operators

The = Operator

The Simple Assignment Operator assigns a simple value to a variable.
Simple Assignment Examples

let x = 10;
let x = 10 + y;

The += Operator

The Addition Assignment Operator adds a value to a variable.
Addition Assignment Examples

let x = 10;
x += 5;

The -= Operator

The Subtraction Assignment Operator subtracts a value from a variable.
Subtraction Assignment Example

let x = 10;
x -= 5;

The *= Operator

The Multiplication Assignment Operator multiplies a variable.
Multiplication Assignment Example

let x = 10;
x *= 5;

The **= Operator

The Exponentiation Assignment Operator raises a variable to the power of the operand.
Exponentiation Assignment Example

let x = 10;
x **= 5;

The %= Operator

The Remainder Assignment Operator assigns a remainder to a variable.
Remainder Assignment Example

let x = 10;
x %= 5;

JavaScript Comparison

Comparison Operators

Comparison operators are used to compare two values.

Comparison operators always return true or false.

Given that x = 5, the table below explains the comparison operators:

JavaScript String Comparison

All the comparison operators above can also be used on strings:
Example

let text1 = "A";
let text2 = "B";
let result = text1 < text2;

Comparing Different Types

Comparing data of different types may give unexpected results.

When comparing a string with a number, JavaScript will convert the string to a number when doing the comparison. An empty string converts to 0. A non-numeric string converts to NaN which is always false.

Example

age = Number(age);
if (isNaN(age)) {
  voteable = "Input is not a number";
} else {
  voteable = (age < 18) ? "Too young" : "Old enough";
}

JavaScript Conditionals

Conditional Statements

Conditional Statements allow us to perform different actions for different conditions.

Conditional statements run different code depending on true or false conditions.

Conditional statements include:

if
if...else
if...else if...else
switch
ternary (? :)

When to use Conditionals

*Use if to specify a code block to be executed, if a specified condition is true
*Use else to specify a code block to be executed, if the same condition is false
*Use else if to specify a new condition to test, if the first condition is false
*Use switch to specify many alternative code blocks to be executed
*Use (? :) (ternary) as a shorthand for if...else

The if Statement

Use if to specify a code block to be executed, if a specified condition is true.

Syntax
if (condition) {
  // code to execute if the condition is true
}

Conversion Types in JavaScript & JavaScript Type Coercion

Madhan Raj — Tue, 02 Jun 2026 08:19:31 +0000

JavaScript Type Conversion

*Converting Strings to Numbers
*Converting Numbers to Strings
*Converting Dates to Numbers
*Converting Numbers to Dates
*Converting Booleans to Numbers
*Converting Numbers to Booleans

JavaScript variables can be converted to a new variable and another data type:

By the use of a JavaScript function
Automatically by JavaScript itself

Converting Strings to Numbers

The global method Number() converts a variable (or a value) into a number.

A numeric string (like "3.14") converts to a number (like 3.14).

An empty string (like "") converts to 0.

A non numeric string (like "John") converts to NaN (Not a Number).
Converting Numbers to Strings

The global method String() can convert numbers to strings.

It can be used on any type of numbers, literals, variables, or expressions:
Example

String(x)         // returns a string from a number variable x
String(123)       // returns a string from a number literal 123
String(100 + 23)  // returns a string from a number from an expression

Converting Booleans to Numbers

The global method Number() can also convert booleans to numbers.
Number(false) // returns 0
Number(true) // returns 1

Converting Booleans to Strings

The global method String() can convert booleans to strings.
String(false) // returns "false"
String(true) // returns "true"

The Boolean method toString() does the same.

false.toString()   // returns "false"
true.toString()    // returns "true"

**Reasons to Learn JavaScript Type Conversion**

    Data Handling: In JavaScript when we are working with API responses, user inputs and calculations, these type of the operation require type conversion.
    Prevent Bugs: It is important to understand the type conversion which can help in preventing bugs which occurs when JavaScript implicitly converts value.
    Code Clarity: By performing the explicit conversion makes our code bug free and more clear.

JavaScript Type Coercion

Type Coercion

Type coercion is the automatic conversion of values from one data type to another.

Type coercion happens when you perform an operation on different data types, and the JavaScript engine tries to make them "fit" together.

Example

JavaScript coerces types differently per operator, so type coercion can hide bugs.

Program continues according to the coercion rules, but these may differ from what the programmer wanted to achieve.

let result1 = ('5' + '2'); // = 52
let result2 = ('5' - '2'); // = 3

Coercion is implicit (handled automatically by the engine), while type conversion is explicit (you manually use functions like Number() or String()).

Because JavaScript is weakly typed, it doesn't throw errors when types don't match; it just tries to coerce them.

String Coercion (+)

If any part of a + operation is a string, JavaScript converts everything to strings and concatenates them.

let x = "5" + 2 // x = "52"

Numeric Coercion

Other arithmetic operators (-, *, /, %) and the unary plus (+x) force values into numbers.

let x = "5" - 2 // x = 3

Boolean Coercion

Values are coerced to booleans in logical contexts like if statements or using the double-NOT operator (!!).

Falsy values: 0, "", null, undefined, NaN, and false.

Truthy values: Everything else (including empty objects {} and arrays []).