Forem: Anees Abdul

Synchronous/Asynchronous JavaScript

Anees Abdul — Thu, 30 Apr 2026 08:22:53 +0000

What is Synchronous JavaScript?

It means the operations are performed one after the other. So, each line of code should wait for the previous one to finish before proceeding to the next.
JavaScript is a single-threaded and synchronous language by default

console.log("Start");
console.log("Middle");
console.log("End");

Start
Middle
End

Disadvantages of Synchronous:

Blocking Execution (Each task must finish before the next starts)
Slower Performance ( long task delays the entire program)
UI becomes unresponsive

What is Asynchronous JavaScript?

It allows multiple tasks to run independently.
Whenever a task is initiated and while waiting for it to complete, other tasks can proceed. This results in a non-blocking nature and improves performance.

 <script>
  console.log("Start");
  setTimeout(()=>{
      console.log("Async Task");
      },2000);
   console.log("End");
    </script>

Start
End
Async Task

How Asynchronous JavaScript works:

To understand the behavior better, it's important to know about the JS environment.
Call Stack
Web API's in Browser
Callback Queue
Event Loop

Call Stack:

This is where the functions are executed in the order they are called.
function is added to the stack and executed before moving to the next

Web API(Browser):

functions like setTimeout, HTTP requests, and event listeners are handled by these browser API
When an Asynchronous function like setTimeout is called, it is passed to the browser, which manages the timing without blocking the main call stack

Callback Queue

Once the Web API has finished its job (like waiting for the timeout), it pushes the callback function (like the one in setTimeout) to the callback queue

Event Loop

It checks the call stack to see if it's empty and pushes the function from the callback queue to the stack for execution.

Several methods that can be used to perform asynchronous JavaScript tasks are listed below:

setTimeout
callback
promises

What is setTimeout:

This function is used to delay the execution of the code, and this method executes a function after waiting for a specified number of milliseconds

setTimeout(function,delay)

console.log("Start");
setTimeout(()=>{
console.log("Hello after 2 seconds");
},2000);
console.log("End");

Start
End
Hello after 2 seconds

Disadvantages of setTimeout:

Delay is minimum time, not guaranteed
Delay depends on the system, which may be execution
When nested callbacks happen, it results in callback Hell, which makes the code hard to read

What is Promise function:

It is useful for handling asynchronous operations like API calls, file loading, or time delays more easily.

It has three states:

Pending- The task in the initial state
Fulfilled- The task was completed successfully, and the result is available
Rejected - The task failed, an error is provided

let promise= new Promise(resolve,reject)=>{
//Perform async operation
if(operationSuccessful){
resolve("Task Successfull");
}else{
reject("Task failed");
}
});

Note: The "resolve" and "reject" are not keywords. You can use any name that you want to give to a function

  function myPromise(){
        return new Promise((res,rej)=>{
        let movieTicket=true;
        if(movieTicket)
        res(350)
        else
        rej()
     })
     }

     myPromise().then((amt)=>console.log(`Enjoy the movie, I have sent ${amt}`))
     myPromise().catch(()=>console.log("Sorry! Try to book for another movie")
O/P:
Enjoy the movie, I have sent 350

JavaScript DOM

Anees Abdul — Tue, 28 Apr 2026 14:31:59 +0000

DOM stands for Document Object Model.
Document can be any file(HTML, XML), object can be Tags and Elements (h1 and p) And the model is the layout of the structure

What is HTML DOM:

The HTML DOM is a standard object model and programming interface for HTML
It defines:
- The HTML elements as objects and the properties of all HTML elements, and also the methods to access the elements.
In simple words, it is a standard for how to get, change, add, or delete HTML elements

Why is DOM needed:

Using this, we can change the HTML elements, attributes, and CSS styles in the page
We can add/remove existing HTML elements and attributes
React to events from HTML elements

How to select Elements:
-Selecting HTML elements using JavaScript so we can interact with them.

There are several ways to find elements:

Finding Elements by id
Finding Elements by tag name
Finding Elements by class name
Finding Elements by css selectors
Finding Elements by HTML object collections

1. Find Elements by id:

If the element is found, the method will return the element as an object(in Element)
If the element is not found then it will contain null

<h1 id="title">Hello World</h1>
let el = document.getElementById("title");
console.log(el.innerText);//Hello World

2. Find Elements by TagName:

<h1 id="title">Hello World</h1>
<p>First</p>
<p>Second</p>
<script>
const eleByTag=document.getElementsByTagName("p");
console.log(eleByTag[0].innerText);/First
</script>

3. Find Elements by ClassName:

<h1 id="title">Hello World</h1>
<p class="one">First</p>
<p class="two">Second</p>
<script>
const eleByTag=document.getElementsByClassName("two");
console.log(eleByTag[0].innerText);//Second
</script>

4. Find Elements by CSS selectors:

CSS selectors allow us to access DOM elements using querySelector and querySelectorAll by specifying id, class, tag, or more complex patterns.

What is querySelector():

It will return the first matching Element

<p class="text">Hello</p>
<p class="text">World</p>

let el = document.querySelector(".text");
console.log(el.innerText);/ return only the first match and second is ignored

If you want to select all matching elements then go for querySelectorAll()

What is querySelectorAll():

It will return the all matching elements(Node List)
If you want to access one element at a time then mention the index

   <p class="one">First</p>
   <p class="two">Second</p>
   <p class="two">Third</p>
<script>
const selector=document.querySelectorAll(".two")
console.log(selector[1].innerText);/Third
    </script>

You can also Loop through all when using querySelectorAll()

   <p class="one">First</p>
   <p class="two">Second</p>
   <p class="two">Third</p>

<script>
const selector=document.querySelectorAll(".two")
for(let i=0;i<selector.length;i++){
    console.log(selector[i].innerText);//Second,Third
} </script>

5. Find Elemnts using Collections(HTML collection/NodeList):

-It will return multiple elements so use getElementsBy

When multiple elements are returned, we must iterate through the collection using loops or forEach to access individual elements.

   <p class="one">First</p>
   <p class="two">Second</p>
   <p class="two">Third</p>

<script>
const selector=document.querySelectorAll(".two")
for(let i=0;i<selector.length;i++){
    console.log(selector[1].innerText);//Third
}
</script>

How to Change Elements:

The HTML DOM allows JavaScript to change both the text and the content of HTML elements.

1. Change the content of an

element:

   <h1 id="title">Hello World</h1>
<script>
const Ele=document.getElementById("title").innerText="Changed Element";
console.log(Ele)//Changed Element
    </script>

2. Changing the attribute:

<img id="img" src="old.png">
let img = document.getElementById("img");
img.setAttribute("src", "new.png");//new.png

3. Changing CSS style:

   <h1 id="title">Hello World</h1>
<script>
const Ele=document.getElementById("title");
Ele.style.color="red";
Ele.style.fontSize="20px";
Ele.style.backgroundColor="Blue"
</script>

How to create elements:

The createElement() method creates an element node.

<p>Old content:</p>

<script>
// Create element:
const para = document.createElement("p");
para.innerText = "changed paragraph";
// Append to body:
document.body.appendChild(para);
</script>
O/P: Testing Paragraph:
     changed Paragraph

How to remove Elements:

The remove() method removes an element (or node) from the document.

element.remove()

How to setAttribute():

-setAttribute() is used to add or update an HTML attribute of an element

<button id="btn">Click Me</button>
let btn = document.getElementById("btn");
btn.setAttribute("type", "submit");

String in JS!

Anees Abdul — Wed, 22 Apr 2026 14:01:40 +0000

What is String:

A string is a sequence of characters, used to represent a text, and it should be enclosed in either "" or '' and can be used even in template literals, which allows embedding in backticks ``

Basic operations on Strings:
1. Find the length of a String:

Returns the number of characters in a string

let fruits = "JackFruit"; console.log(fruits.length); //Output: 9

2. String Replace:

replace a substring/pattern in the string

`javascript str.replace(pattern, replacement) `

`javascript let fruits = "JackFruit and JackFruit"; let result=fruits.replace("JackFruit", "Banana"); console.log(result); O/P: Banana `

By default, replace() only replaces the first occurrence. To replace all occurrences, use a regular expression with the g flag.

`javascript let fruits = "JackFruit and JackFruit"; let result=fruits.replace(/JackFruit/g, "Banana"); console.log(result); O/P: Banana and Banana `

3. String charAt():

Returns character at a specified index in a string

`javascript let fruits = "JackFruit"; console.log(fruits.charAt(3)); O/P: K `

4. String charCodeAt():

Returns Unicode of the character at given index

`javascript let fruits = "JackFruit"; console.log(fruits.charCodeAt(3)); O/P: 107 `

5. String concat():

Concatenates the arguments to the calling string

`javascript let fruit1 = "JackFruit"; let fruit2 = "Apple"; console.log(fruit1.concat(" and ",fruit2)); O/P: JackFruit and Apple `

6. String at():

at() method returns the character at a specified index (position) in a string.
at() supports negative index

`javascript
let str = "Hello";

console.log(str.at(-1));
O/P: o
`

7. String slice():

Extracts and returns a section of the string

`javascript
const message = "JavaScript is fun";

// slice the substring from index 0 to 10
let result = message.slice(0, 10);
console.log(result);

// O/P: JavaScript
`

8. String substring():

substring() is similar to slice().

`javascript
let message = "JavaScript is fun";

console.log(message.substring(3,10))
O/P: aScript
`

8. String toUppercase() and toLowervcase():

Returns the uppercase/lowercase of a string

`javascript
let message = "JavaScript is fun";
console.log(message.toUpperCase());
//JAVASCRIPT IS FUN
let message = "JavaScript is fun";
console.log(message.toLowerCase());
//javascript is fun

9. String trim():

Removes whitespace from both ends of a string

`javascript let message = " JavaScript is fun"; console.log(message.trim()); O/P: JavaScript is fun `

String trimStart():

Remove whitespace only from the Starting point

String trimEnd()

Remove whitespace only at the End point

10. String padStart()

Pads a string at the start to a given length

`javascript

let string1 = "CODE";

// padding "" to the start of given string
// until the length of final padded string reaches 10
let paddedString = string1.padStart(10, "");

console.log(paddedString);

// Output: ******CODE
`

** String padEnd()**

Pads a string at the end to a given length

`javascript
// string definition
let string1 = "CODE";

// padding "" to the end of the given string
// until the length of final padded string reaches 10
let paddedString = string1.padEnd(10, "");

console.log(paddedString);
// Output: CODE******
`

11. String repeat():

Returns a string by repeating it given times

`javascript let string1="CODE"; console.log(string1.repeat(2)); // Output: CODECODE `

12.String split():

Returns the string divided into a list of substrings
Returns an Array of strings, split at each point where the separator occurs in the given string.

`javascript
const message = "JavaScript::is::fun";

// divides the message string at ::
let result = message.split("::");
console.log(result);
// Output: [ 'JavaScript', 'is', 'fun' ]
`
13. String indexOf():

It returns the index of the first occurrence of the substring in a string.

`javascript let message = "JavaScript is not Java"; let index = message.indexOf("va"); console.log('index: ' + index); // index: 2 `
14. String lastIndexOf():

It returns the last index of occurence of a given substring in the string.
Both indexOf(), and lastIndexOf() return -1 if the text is not found

`javascript let str = "I love JavaScript"; let result = str.lastIndexOf("Script") console.log(result); O/P:11 `
15. String search():

It searches for a string and returns the position of the match.

`javascript let text = "Please locate where 'locate' occurs!"; text.search("locate"); O/P: 7 `
16. String match():

It returns the result of matching a string against a regular expression.
If you need to search the string entirely then use global search (/text/g)
If you want to perform case insensitive too then add (/text/gi)

`javascript let text = "JavaScript is not a java" console.log(text.match(/Ja/gi)); O/P: ['Ja', 'ja'] `
17. String matchAll():

It returns an iterator of results after matching a string against a regular expression.

`javascript let text = "I love cats. Cats are very easy to love. Cats are very popular." const iterator = text.matchAll(/Cats/gi); console.log([...iterator]); `

`plaintext 0: ['cats'] 1: ['Cats'] 2: ['Cats'] `

18. String includes():

It returns true if a string contains a specified value.

`javascript let message = "JavaScript is fun"; let result = message.includes("Java"); console.log(result); O/P: true `

String startsWith():
The startsWith() method returns true if a string begins with a specified value.

`javascript let text = "Hello world, welcome to the universe."; let result=text.startsWith("Hello"); console.log(result); O/P: true `
20: String endsWith():

The endsWith() method returns true if a string ends with a specified value. Otherwise return false

String Methods in JS

Anees Abdul — Tue, 21 Apr 2026 15:07:36 +0000

What is String:

A string is a sequence of characters, used to represent a text, and it should be enclosed in either "" or '' and can be used even in template literals, which allows embedding in backticks ``

Basic operations on Strings:

1. Find the length of a String:

Returns the number of characters in a string

`javascript let fruits = "JackFruit"; console.log(fruits.length); `

`javascript
let fruits = "JackFruit";
console.log(fruits.length);

O/P:
9
`

2. String Replace:

replace a substring/pattern in the string

`javascript str.replace(pattern, replacement) `
`javascript let fruits = "JackFruit and JackFruit"; let result=fruits.replace("JackFruit", "Banana"); console.log(result); O/P: Banana `

By default, replace() only replaces the first occurrence. To replace all occurrences, use a regular expression with the g flag.

`javascript let fruits = "JackFruit and JackFruit"; let result=fruits.replace(/JackFruit/g, "Banana"); console.log(result); O/P: Banana and Banana `
3. String charAt():

Returns character at a specified index in a string

`javascript let fruits = "JackFruit"; console.log(fruits.charAt(3)); O/P: K `
4. String charCodeAt():

Returns Unicode of the character at given index

`javascript let fruits = "JackFruit"; console.log(fruits.charCodeAt(3)); O/P: 107 `
5. String concat():

Concatenates the arguments to the calling string

`javascript let fruit1 = "JackFruit"; let fruit2 = "Apple"; console.log(fruit1.concat(" and ",fruit2)); O/P: JackFruit and Apple `
6. String at():

at() method returns the character at a specified index (position) in a string.
at() supports negative index

`javascript
let str = "Hello";

console.log(str.at(-1));
O/P: o
`
7. String slice():

Extracts and returns a section of the string

`javascript
const message = "JavaScript is fun";

// slice the substring from index 0 to 10
let result = message.slice(0, 10);
console.log(result);

// O/P: JavaScript
`
8. String substring():

substring() is similar to slice().

`javascript
let message = "JavaScript is fun";

console.log(message.substring(3,10))
O/P: aScript
`
8. String toUppercase() and toLowervcase():

Returns the uppercase/lowercase of a string

`javascript
let message = "JavaScript is fun";
console.log(message.toUpperCase());
//JAVASCRIPT IS FUN
let message = "JavaScript is fun";
console.log(message.toLowerCase());
//javascript is fun

`
9. String trim():

Removes whitespace from both ends of a string

`javascript let message = " JavaScript is fun"; console.log(message.trim()); O/P: JavaScript is fun `
String trimStart():

Remove whitespace only from the Starting point String trimEnd()
Remove whitespace only at the End point

10. String padStart()

Pads a string at the start to a given length

`javascript

let string1 = "CODE";

// padding "" to the start of given string
// until the length of final padded string reaches 10
let paddedString = string1.padStart(10, "");

console.log(paddedString);

// Output: ***CODE
`
* String padEnd()

Pads a string at the end to a given length

`javascript
// string definition
let string1 = "CODE";

// padding "" to the end of the given string
// until the length of final padded string reaches 10
let paddedString = string1.padEnd(10, "");

console.log(paddedString);

// Output: CODE******
`
11. String repeat():

Returns a string by repeating it given times

`javascript
let string1="CODE";
console.log(string1.repeat(2));

// Output: CODECODE
`
12. String split():

Returns the string divided into a list of substrings
Returns an Array of strings, split at each point where the separator occurs in the given string.

`javascript
const message = "JavaScript::is::fun";

// divides the message string at ::
let result = message.split("::");
console.log(result);

// Output: [ 'JavaScript', 'is', 'fun' ]
`

Arrays in Javascript

Anees Abdul — Sat, 18 Apr 2026 15:29:39 +0000

What is an Array:

An array is a collection of values stored in a single variable. Instead of creating multiple variables:

let a = 10;
let b = 20;
let c = 30;

we can use Array:

let numbers=[10,20,30];

Creating an array using literal:

Creating Empty Array:
let a=[];
console.log(a);

Initalize values:
let b=[10,20,30];
console.log(b);

O/P:
[]
10,20,30

Creating using new Keyword(constructor):

let a= new Array(10,20,30);
console.log(a)
O/P:
[10,20,30]

1. Accessing Elements of an Array:
Any element in the array can be accessed using the index number. The index in the arrays starts with 0.

let fruits = ["apple", "banana", "mango"];

Using index:
console.log(fruits[0]);
O/P:
apple

First element:
let a=fruits[0];
console.log(a);
O/P:
apple

Last element:
let last=fruits[fruits.length-1];
console.log(last);
O/P:
mango

2. Modifying Array elements:

let fruits = ["apple", "banana", "mango"];
fruits[1] = "orange";
console.log(fruits);
O/P:
["apple", "orange", "mango"]

3. Adding Elements to the Array:

Elements can be added using push() and unshift() methods

push() → add at end
fruits.push("grape");
O/P:
"apple", "banana", "mango", "grape"

unshift() → add at beginning
fruits.unshift("kiwi");
"kiwi", "apple", "banana", "mango", "grape"

4. Removing Elements from an Array

To remove the elements from an array we have different methods like pop(), shift(), or splice().

pop() → remove last
fruits.pop();

shift() → remove first
fruits.shift();

5. Array Length:

let fruits = ["apple", "banana", "mango"];
console.log(fruits.length);

O/P:
3

6. Increase and Decrease the Array Length:

let fruits = ["apple", "orange", "kiwi"]
console.log(fruits.length);
fruits.length=7;
console.log(fruits);
O/P:
3
7 ['apple', 'orange', 'kiwi', empty × 4]

7. Iterating Through Array Elements
We can iterate array and access array elements using for loop and forEach loop.

let fruits = ["apple", "orange", "kiwi"]
for(let i=0;i<fruits.length;i++){
    console.log(fruits[i])
O/P:
apple
orange
kiwi

8. Array Concatenation

let fruits = ["apple", "orange", "kiwi"]
let basket=[1,2];
console.log(fruits.concat(basket));

O/P:
['apple', 'orange', 'kiwi', 1, 2]

9. Conversion of an Array to String
We have a builtin method toString() to converts an array to a string.

let fruits = ["apple", "orange", "kiwi"]
console.log(fruits.toString());
O/P:
apple,orange,kiwi

Objects in Javascript:

Anees Abdul — Fri, 17 Apr 2026 14:27:35 +0000

What is object:

An object is a collection of key-value pairs.
The values of properties can be primitives, objects, or functions (known as methods when defined inside an object).

let person = {
    name: "ABC",
    age: 30,
    city: "Chennai"
};

console.log(person);

{name: "ABC", age: 30, city: "Chennai"}

1. Accessing Object Properties
1️⃣ Dot Notation

console.log(person.name);

2️⃣ Bracket Notation

console.log(person["age"]);

2. Modifying Object Properties

It can be modified by reassigning its values.

let person= { name: "ABC", age: 30 };
console.log(person);

person.age=23//Modifying property
person.name="Test"

3. Adding Properties to an Object

You can dynamically add new properties to an object using dot or bracket notation.

person.country = "India";   // add

console.log(person);

4. Removing Properties from an Object
The delete operator removes properties from an object.

delete person.city;

console.log(person);

{name: "Anees", age: 31, country: "India"}

5. Checking if a Property Exists
You can check if an object has a property using the in operator

let person = { MobileNo: 1231231212 };
console.log("MobileNo" in person);

Adding objects with Methods
Objects can also store functions (called methods)

let person = {
    name: "And",
    greet: function() {
        console.log("Hello " + this.name);
    }
};

person.greet();

O/P:
Hello And

Looping through Object

let person = {
    name: "ABC",
    age: 30
};

for (let key in person) {
    console.log(key + ": " + person[key]);

O/P:
name: ABC
age: 30

Nested Objects
Objects inside objects

let user = {
    name: "ABC",
    address: {
        city: "Chennai",
        pincode: 600001
    }
};

console.log(user.address.city);

O/P:
Chennai

Array of Objects

let users = [
    { name: "ABC", age: 30 },//index 0
    { name: "John", age: 25 }//index 1
];
console.log(users[0].name);

O/P:
ABC

Callback function Examples

Anees Abdul — Thu, 16 Apr 2026 07:37:38 +0000

1. Greet

function welcome(name,cb){

    console.log("Hello: " +name);
    cb(name);

}
function sayBye(name){
    console.log("Bye:" +name);
}
welcome("Jo",sayBye);

Hello: Jo
Bye:Jo

2. Create Account to login

function createAccount(username,password,cb){
console.log("Provide details to login");
cb(username, password);

}
function login(username,password){

    console.log("User logged in:"+username, +password);
}
createAccount("Anees","123", login)

Provide details to login
User logged in:Anees 123

3. Clear interview to get job:

function clearInterview(cb){
    console.log("Selected");
     cb();

}
function gotJob(cb){
    console.log("Got placed");


}
clearInterview(gotJob);

Selected
Got placed

4. Even Number Check:

function check(a,cb){
console.log("Enter the number to check: " +a);
cb(a);
}
function evenNumberorNot(no){

console.log(no%2==0 ? "Even": "odd")

}
check(4,evenNumberorNot);

Enter the number to check: 4
Even

5. setTimeout Example

function fetchData(cb){
console.log("Fetching data");
//setTimeout(function,timeinMilliseconds);
setTimeout(()=>{
            let data={name:"User", age: "30"};
            cb(data);
            },2000);
}
function displayData(data){
    console.log("User:"+data.name, data.age);
}

fetchData(displayData);

Fetching data
User:User 30

Functions in JavaScript

Anees Abdul — Wed, 08 Apr 2026 14:07:24 +0000

What is a Function?
-A function is a block of code designed to perform a specific task.

Instead of writing the same code again and again, we can put it inside a function and reuse it.

function functionName() {
    // code to execute
}

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

greet(); // calling the function
O/P: Hello

Functions with Parameters

Parameters allow you to pass values into a function.

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

greet("Anees");
O/P: Hello Anees

Functions with Return Value

A function can return a value using return.

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

let result = add(2, 3);
console.log(result);
O/P: 5

Types of Functions in JavaScript
1- Function Declaration
2- Function Expression
3- Arrow Functions (Modern JavaScript)
4- Anonymous Function
5- Callback Function
6- IIFE (Immediately Invoked Function)

What is Function Declaration:

A function declaration (or simply a function) is defined using:
The function keyword
function name
Parameters in parentheses
code block brackets

Hoisted (can be used before declaration)

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

function show() {
    console.log("Function Declaration");

What is Function Expression:
A function expression is a way of creating a function and assigning it to a variable.

A function expression is defined using:

The function keyword
Parameters in parentheses
A code block brackets

Not hoisted - Must be defined before calling.

const add = function(a, b) {return a + b;};

const add = function(a, b) {
    return a + b;
};

console.log(add(3, 4));

O/P:7

What is Arrow Function:

Arrow Functions allow a shorter syntax for function expressions.

You can skip the function keyword, the return keyword, and the curly brackets:

An arrow function uses the => symbol.
An arrow function is always written as a function expression.

const multiply = (a, b) => a * b;
console.log(multiply(3,4));
O/P: 12

What is an Anonymous Function:

An anonymous function is a function without a name.
It is usually used where functions are needed temporarily. Often used in timers or callbacks.

setTimeout(function() {
    console.log("Hello after delay");
}, 1000);
O/P: Hello after delay

What is Callback Function:

A callback function is a function passed as an argument to another function. -It is executed after a specific task is completed. Commonly used in asynchronous operations.

function process(name, callback) {
    console.log("Processing " + name);
    callback();
}

function done() {
    console.log("Done!");
}

process("Anees", done);

O/P: 
Processing Anees
Done!

How it works

process is called
Prints "Processing Anees"
Calls callback()
done() runs

What is IIFE (Immediately Invoked Function):

An IIFE is a function that runs immediately after it is created. No need to call it separately.

(function() {
    console.log("IIFE executed");
})();
O/P: IIFE executed

What is Closure:

A closure is a function that remembers variables from its outer function. Even after the outer function finishes, the inner function can still access those variables. Used for data privacy and maintaining state.

Looping Statements in JavaScript!

Anees Abdul — Mon, 06 Apr 2026 14:25:38 +0000

What is a Loop?
A loop repeats a set of instructions until a condition is met.

Example:
Instead of writing console.log("Hello") 5 times, we can use a loop.

Types of Loops in JavaScript
JavaScript provides several types of loops:

for loop
while loop
do...while loop
for...of loop(To be discussed)
for...in loop

1. for loop:

for loop is used to execute a block of code repeatedly, until a specified condition evaluates to false.

for (initialization; condition; increment/decrement) {
    // code to execute
}

Best used when you know how many times to loop.

for (let i = 1; i <= 5; i++) {
    console.log("Hello " + i);
}
O/P: 
Hello 1
Hello 2
Hello 3
Hello 4
Hello 5

2. while Loop:
The while loop runs as long as the condition is true.

while (condition) {
    // code
}

Used when the number of iterations is not fixed.

let i = 1;

while (i <= 5) {
    console.log(i);
    i++;
}
O/P:
1
2
3
4
5

3. do...while Loop:
This loop runs at least once, even if the condition is false.

do {
    // code
} while (condition);

Useful when the code must run at least once.

let i = 1;

do {
    console.log(i);
    i++;
} while (i <= 5);

4. for...of Loop:
Used to iterate over the values of arrays or strings.
Best for arrays and iterable objects.

let fruits = ["apple", "banana", "mango"];

for (let fruit of fruits) {
    console.log(fruit);
}
O/P:
apple
banana
mango

5. for...in Loop:
Used to iterate over keys (properties) of an object.
Best for objects.

let person = {
    name: "Anees",
    age: 30
};

for (let key in person) {
    console.log(key + ": " + person[key]);
}
O/P:
name: Anees
age: 30

Important Keywords:

break
continue

break: Stops the loop completely.

for (let i = 1; i <= 5; i++) {
    if (i === 3) break;
    console.log(i);
}
O/P:
1
2

continue: Skips the current iteration.

for (let i = 1; i <= 5; i++) {
    if (i === 3) continue;
    console.log(i);
}
O/P:
1
2
4
5

Advantages of Loops

Saves time and reduces code duplication
Makes code cleaner and readable
Handles repetitive tasks easily
Useful in arrays, objects, and automation

JavaScript program task-1

Anees Abdul — Mon, 06 Apr 2026 14:23:25 +0000

1) 1 1 1 1 1

let output = " ";
for(let i=1;i<=5;i++){
    output +=" 1";
    }
console.log(output);

1 1 1 1 1

2) 1 2 3 4 5

let output = " ";
for(let i=1;i<=5;i++){
    output += i + " ";
    }
console.log(output);

1 2 3 4 5

let output = " ";
for(let i=1;i<=10;i++){
    if(i%2!=0){
    output += i + " ";
    }
}
console.log(output);

 1 3 5 7 9

let output = " ";
for(let i=3;i<=15;i++){
    if(i%3==0){
    output += i + " ";
    }
}
console.log(output);

3 6 9 12 15

5) Multiples of 3 and 5

let output = " ";
for( let i=1;i<=50;i++){
    if((i%3==0)&&(i%5==0)){
        output +=i + " ";
    }
}
console.log(output);

 15 30 45

6) Multiples of 3 or 5

let output = " ";
for( let i=1;i<=50;i++){
    if((i%3==0)||(i%5==0)){
        output +=i + " ";
    }
}
console.log(output);

 3 5 6 9 10 12 15 18 20 21 24 25 27 30 33 35 36 39 40 42 45 48 50

7) Divisors of given number

let number=10;
for( let i=1; i<=20;i++){
    if(number%i==0){
        console.log(i);
    }
}

8) Count of Divisors of given number:

let number=10;
let count=0;
for( let i=1; i<=20;i++){
    if(number%i==0){
        //console.log(i);
        count++;

    }

}
 console.log(count);

9) Prime Number:

let number=9;
let count=0;
for( let i=1; i<=number;i++){
    if(number%i==0){
        count++;
    }
}
if(count==2){
    console.log("Is a Prime number");

}else{
    console.log("Not a Prime");
}

Not a Prime

10) Reverse a Number:

let number=1234;
let answer=0;

while(number>0){
    let digit=number%10;
    answer=answer*10+digit;
    number=Math.floor(number/10);
}
console.log(answer);

Task on Looping Statement

Anees Abdul — Fri, 03 Apr 2026 10:51:10 +0000

1) Print numbers from 1 to 5:

FlowChart:

let i=1;
   for(i=1;i<=5;i++){
    console.log(i);
   } 
O/P:
1
2
3
4
5

2) Program to print numbers 5 4 3 2 1
FlowChart:

for(let i=5;i>=1;i--){
    console.log(i);
}
O/P: 
5
4
3
2
1

3) Print even numbers from 1 to 10
FlowChart:


for(let i=1;i<=10;i++){
    if(i%2==0){
        console.log(i);
    }
}
O/P:
2
4
6
8
10

Conditional Statements in JavaScript:

Anees Abdul — Thu, 02 Apr 2026 11:50:30 +0000

What are Conditional Statements in JavaScript?

Conditional statements are used to make decisions in a program.

Conditional statements include:

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

1. if Statement:

Executes code only if the condition is true

let age = 20;

if (age >= 18) {
  console.log("You are an adult");
}

2. else Statement:

Use else to specify a code block to be executed if the same condition is false.

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

3. else if Statement:

Used to check multiple conditions

let marks = 75;

if (marks > 90) {
  console.log("Excellent");
} else if (marks > 60) {
  console.log("Good");
} else {
  console.log("Average");
}

4. switch Statement:

Used to compare one value with multiple cases

let day = 2;

switch (day) {
  case 1:
    console.log("Monday");
    break;
  case 2:
    console.log("Tuesday");
    break;
  default:
    console.log("Invalid");
}

Ternary Operator:

Short form of if-else

condition ? expression1 : expression2


If the value of age is < 18, 
set the value of text to "Minor", otherwise to "Adult":

let text = (age < 18) ? "Minor" : "Adult";

Important Concepts of javascript is: Truthy Falsy:

In JavaScript, every value is treated as either true or false when used inside a condition.

This is known as truthy and falsy values

Truthy → behaves like true
Falsy → behaves like false

Falsy Values:
Falsy values are values that are considered false in a boolean context.

List of Falsy Values:

false
0
""
null
undefined
NaN

Example of Falsy:

let value = 0;

if (value) {
  console.log("Truthy");
} else {
  console.log("Falsy");
}

O/P: Falsy

Truthy Values

All values except falsy values are truthy.

Why It is Important:

*Reduces code length (no need for multiple conditions)
*Reduces unnecessary comparisons
*Useful for checking if a value exists
*Widely used in real-time applications (forms, APIs, login)