DEV Community: Madhavan G

JavaScript Array Iterations.

Madhavan G — Wed, 15 Apr 2026 15:42:16 +0000

What is Iteration?
Iterations refer to the process of repeating a block of code multiple times, usually using loops. It’s a fundamental concept used when you want to perform the same operation over a collection of data or until a condition is met.

JavaScript Array Iterations:

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 (...)

⇒Array forEach:

•The forEach() method calls a function (a callback function) once for each array element.
Example:
let nums = [1, 2, 3];
nums.forEach(n => console.log(n * 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

Screenshot of the program:

⇒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.

Example:

let nums = [1, 2, 3, 4, 5];
let doubled = nums.map(n => n * 2);
console.log(doubled);

Screenshot of the program:

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

Example:

let arr = [1, 2, 3, 4, 5];
let result = arr.flatMap(n => [n, n * 2]);
console.log(result);

Screenshot of the program:

⇒Array filter():
•The filter() method creates a new array with array elements that pass a test.

Example:

let nums = [1, 2, 3, 4];
let even = nums.filter(myFunction);
console.log(even);
function myFunction(value){
return (value%2===0)
}

Screenshot of the program:

⇒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.
In reduce(), the callback function is called for every element, and it receives 4 arguments:

array.reduce((accumulator, currentValue, index, array) =>
{
// logic
}, initialValue);

accumulator (acc):

👉The running result
•Stores the result from previous steps
•Updated and passed forward each iteration

2.currentValue (n / item):

👉 The current array element

3.index (optional):

👉 Position of current element

4.array (optional):

👉 Original array itself

Example:

let nums = [1, 2, 3, 4];
let sum = nums.reduce(myFunction,0)
function myFunction(acc,n){
return acc+n;
}
console.log(sum)

// In arrow funtion
let nums = [1, 2, 3, 4];
let sum = nums.reduce((acc, n) => acc + n, 0);
console.log(sum);//10

Screenshot of the program:

⇒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.

Example:
let arr = ["1", "2", "3", "4"];
let result = arr.reduceRight(myFunction)
function myFunction(acc,n){
return acc+n;
}
console.log(result)

//In arrow funtion
let arr = ["1", "2", "3","4"];
let result = arr.reduceRight((acc, val) => acc + val);
console.log(result);

Screenshot of the program:

⇒Array every():

•The every() method checks if all array values pass the condition.

Example:

const numbers = [45, 4, 9, 16, 25];
let result = numbers.every(myFunction);
function myFunction(value, index, array) {
return value > 18;
}
console.log(result)

// In arrow funtion
// let number = [45,4,8,16,25];
// let result = number.every((val) =>val>18);
// console.log(result);

What does every() do?

👉 every() checks:

“Do ALL elements satisfy the condition?”

✔ If ALL are true → returns true
❌ If even ONE is false → returns false

Screenshot of the program:

JavaScript Callbacks.

Madhavan G — Tue, 14 Apr 2026 15:34:08 +0000

A JavaScript callback is a function passed as an argument to another function, which is then executed (or "called back") at a later point in time to complete a specific task.

This mechanism is fundamental to JavaScript's event-driven and asynchronous programming model.

What is a Callback Function?
A callback function is a function passed as an argument into another function.

A callback function is intended to be executed later.

Types of Callbacks
Asynchronous Callbacks:
Asynchronous callbacks are executed at a later time, allowing the main program to continue running without waiting.

This is essential for preventing the application from freezing during long-running tasks like network requests.

Synchronous Callbacks
Synchronous Callbacks are executed immediately within the outer function, blocking further operations until completion.

Array methods like map(), filter(), and forEach() use synchronous callbacks.

JavaScript Explained: From Basics to Data Types and Variables.

Madhavan G — Thu, 09 Apr 2026 18:05:09 +0000

WHAT IS JAVASCRIPT?

•JavaScript (JS) is a lightweight interpreted (or just-in-time compiled) programming language with first-class functions.

•It is most well-known as the scripting language for Web pages.

•Many non-browser environments also use it, such as Node.js, Apache CouchDB and Adobe Acrobat.

•It is used for interact web application and supports both client side and server side development.

•Client side means code runs on the user's computer and server side means it's runs on the web browser.

•JavaScript is a single-threaded language that executes one task at a time.

⇒ What is Just-In-Time Compilation (JIT)
JIT (Just-In-Time Compilation) is a compilation process in which code is translated from an intermediate representation or a higher-level language (e.g., JavaScript or Java bytecode) into machine code at runtime, rather than prior to execution. This approach combines the benefits of both interpretation and ahead-of-time (AOT) compilation.

⇒ What is Scripting Language?
A scripting language is a programming language designed to write small programs (scripts) that automate tasks or control another program rather than building an entire standalone application.
Example:Javascript,PHP,Bash,Python,etc...

⇒ What is Programming Language?
A programming language is a formal language used to write instructions that a computer can execute, allowing developers to create software applications ranging from simple scripts to complex systems.
Example:Java,C,C#,C++,Rust,etc...

⇒What is datatypes in javascript?
•A data type tells the computer what kind of value a variable holds and what operations can be performed on it.

•In JS we have two main categories of Datatypes they are:
1.Primitive Data Type
2.Non-Primitive Data Type

⇒What is Primitive Data Type in javascript?

•A primitive data type is a basic, predefined data type provided by a programming language as a building block.

•In JavaScript, a primitive (primitive value, primitive data type) is data that is not an object and has no methods or properties.

•Primitive Datatypes are immutable because we cannot change the value of a primitive in memory. You can only reassign the variable.

•Memory Location: They are typically stored in the stack (execution context) because they have a fixed size.

•When comparing primitives, JS checks the actual value, not the
reference.

•Now let see about it types:

Number:
*Its using to denote numbers like
Example:10,23,17...

Boolean:
*Boolean denoted by true or false.

Bigint:
*Normally integer values are number,on the other hand bigint means big numbers.
Ex:784645959265262.

String:
*Strings are set of characters enclosed single' 'or double""quotes.
Example:"welcome to my Blog"

Undefined:
*Undefined is variable can be exist but not value assigned

Null:
Null is denoted by empty value or 0 value.

Symbol:
*Used to create unique identifiers, usually for object property keys.
*Guarantees uniqueness: no two symbols are equal, even if they have the same description.
Example:

const id1 = Symbol("id");
const id2 = Symbol("id");

console.log(id1 === id2); // false → unique!

⇒What is Non-Primitive Data Type in javascript?

•Non-primitive data types are complex, user-defined data types that store references (memory addresses) to objects, rather than the actual data values.

•Non-primitive data types are Mutable.

•Non-primitive types are stored in the heap the variable holds a reference (memory address) to the actual data. When you assign a non-primitive type to another variable, both variables point to the same memory location.

•Now let see about it types:

Object:

•Stores data as key-value pairs.
•Mutable — you can change properties without creating a new object.
Example:

const person = {
name: "Maddy",
age: 22,
};
console.log(person.name); // Maddy
person.age = 23;
console.log(person.age); // 23

Array:

•Ordered list of values.
•Mutable — you can add, remove, or change elements.
Example:

const numbers = [1, 2, 3, 4, 5];

numbers.push(6);

numbers[0] = 10;

console.log(numbers);

Function:

•Functions are objects in JavaScript.
•Can be stored in variables, passed around, and invoked.
Example:

function greet(name) {
return Hello, ${name}!;
}
console.log(greet("Maddy"));

Key Points:
⇒Primitive types are simple data types that store values directly. They are immutable, and each variable holds its own copy of the data.

⇒Non-primitive types are more complex, and variables store references to the data. Changes to one variable can affect others that reference the same data.

⇒what is Variables in Javascript?
•Variables are like containers that store information, such as numbers, text, or even complex data.

•In JavaScript, there are 4 ways to declare variables:
⇒const (Recommended)
⇒let (Recommended)
⇒var (Not Recommended)
⇒Automatically (Not Recommended)

•Each of these has its own rules.

const:
•Variables defined with const cannot be Redeclared.

•Variables defined with const cannot be Reassigned.

•Variables defined with const have Block Scope.

Example for const :
const n = 100;
// n = 200; This will throw an error
console.log(n)

let:
•The let keyword was introduced in ES6 (2015).

•Variables declared with let have Block Scope.

•Variables declared with let must be Declared before use.

•Variables declared with let cannot be Redeclared in the same scope.

Example for let :
let n= 10;
n = 20; // Value can be updated
// let n = 15; //can not redeclare
console.log(n)

var:
•Variables declared with the var always have Global Scope.

•Variables declared with the var keyword can NOT have block scope.

•Variables defined with var can be redeclared.

Example for var :
var n = 5;
console.log(n);

var n = 20; // reassigning is allowed
console.log(n);

Reference:https://developer.mozilla.org/en-US/docs/Web/JavaScript
Reference:https://www.geeksforgeeks.org/javascript/variables-datatypes-javascript/
Reference:https://www.w3schools.com/js/js_syntax.asp

Array Methods in JavaScript.

Madhavan G — Wed, 08 Apr 2026 17:00:19 +0000

what is array in javascript?

In JavaScript, an array is a specialized object used to store an ordered collection of values, where each value is indexed numerically starting from 0.

Core Definition:
An array is a dynamic, zero-indexed, list-like data structure that can hold elements of any type (heterogeneous), including primitives, objects, and even other arrays.

Example:

const arr = [10, "hello", true, { id: 1 }, [1, 2, 3]];

Here:
•10 → Number (primitive)
•"hello" → String (primitive)
•true → Boolean (primitive)
•{ id: 1 } → Object (non-primitive)
•[1, 2, 3] → Array (special type of object)

What "special type of object" means here
*It’s "special" because, unlike a plain object {}, arrays have:

⇒Ordered elements (indexed numerically starting from 0)

⇒Built-in methods for iteration and manipulation (push, pop, map, filter, etc.)

⇒A length property that updates automatically.

⇒Internal optimizations in JavaScript engines to handle sequential memory access efficiently.

⇒So while { } and [ ] are both objects under the hood, arrays are designed for ordered collection management, making them “special.”

Basic Array Methods in Javascript are:

Arrays come with built-in methods that make data manipulation easy.
•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

∗Arraylength:

Definition:
A property that returns or sets the number of elements in an array. Updating it can truncate or expand the array.

Example:
const arr = [10, 20, 30];
console.log(arr.length);

screenshot of program:

∗Array toString()

Definition:
Returns a string representation of the array by converting each element to a string and joining them with commas.

Example:
const arr = [1, 2, 3];
console.log(arr.toString());

screenshot of program:

∗Array at()

Definition:
Returns the element at a specified index, supporting both positive and negative indices (negative indices count from the end).

Example:

const arr = [10, 20, 30];
console.log(arr.at(0)); // 10

screenshot of program:

∗Array join()

Definition:
Returns a string by concatenating all array elements using a specified separator.

Example:
const arr = ["a", "b"];
console.log(arr.join("*"));

screenshot of program:

∗Array pop()

Definition:
Removes and returns the last element of an array, mutating the original array.

Example:
const arr = [1, 2, 3];
arr.pop(2);
console.log(arr);

screenshot of program:

∗Array push()

Definition:
Adds one or more elements to the end of an array and returns the updated length, mutating the original array.

Example:
const arr = [1, 2, 3];
arr.push(4);
console.log(arr);

screenshot of program:

∗Array shift()

Definition:
Removes and returns the first element of an array, shifting remaining elements and mutating the original array.

Example:
const arr = [1, 2, 3];
arr.shift();
console.log(arr);

screenshot of program:

∗Array unshift()

Definition:
Adds one or more elements to the beginning of an array and returns the new length, mutating the original array.

Example:
const arr = [1, 2, 3];
arr.unshift(0);
console.log(arr);

screenshot of program:

∗Array.isArray()

Definition:
A static method that determines whether a given value is an array.

Example:
const arr = [1, 2, 3];
console.log(Array.isArray(arr));
console.log(Array.isArray([1, 2]));
console.log(Array.isArray({}));
console.log(Array.isArray("hello"));

screenshot of program:

∗Array delete (operator)

Definition:
Removes a property from an array at a given index without changing the array length, leaving an empty slot (sparse array).

Example:
const arr = [1,2,3];
delete arr[1];
console.log(arr);

screenshot of program:

∗Array concat()

Definition:
Returns a new array by merging one or more arrays or values without modifying the original arrays.

Example:
const arr = [1,2,3];
const arr1=[4,5];
let res=arr.concat(arr1);
console.log(res);

screenshot of program:

∗Array copyWithin()

Definition:
Copies a sequence of elements within the same array to another position, mutating the original array.

Example:
const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.copyWithin(2, 0);
console.log(fruits);

screenshot of program:

∗Array flat()

Definition:
Returns a new array with nested sub-array elements flattened up to a specified depth.

Example:
const myArr = [[1,2],[3,4],[5,6]];
const newArr = myArr.flat();
console.log(newArr);

screenshot of program:

∗Array slice()

Definition:
Returns a shallow copy of a portion of an array into a new array without modifying the original array.

Example:
const fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
const old = fruits.slice(2);
console.log(old);

screenshot of program:

∗Array splice()

Definition:
Adds, removes, or replaces elements in an array at a specified index, mutating the original array.

Example:

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2, 0, "Lemon", "Kiwi");
console.log(fruits);

screenshot of program:

∗Array toSpliced()

Definition:
Returns a new array with elements added, removed, or replaced at a specified index, without mutating the original array.

Example:

const months = ["Jan", "Feb", "Mar", "Apr"];
const spliced = months.toSpliced(0, 1);
console.log(spliced);

screenshot of program:

Constructor function and Basic Array methods.

Madhavan G — Wed, 08 Apr 2026 06:40:01 +0000

JavaScript is a powerful and flexible language, and two of its most important concepts are constructor functions and arrays.

🔷 What is a Constructor Function?

A constructor function is used to create and initialize multiple objects with the same structure. Instead of writing the same object again and again, you define a template and reuse it.

Think of it like a blueprint for creating objects.

Example:

const student1={
name:"arun",
age:22
}
const student2={
name:"raghu",
age:23
}
const student3={
name:"sandy",
age:21
}
const student4={
name:"vicky",
age:22
}
console.log(student1.name,student1.age)
console.log(student2.name,student2.age)
console.log(student3.name,student3.age)
console.log(student4.name,student4.age)

🔹It's normal object creation for a student details.
🔹This method is enough for one or two person but if we have more than 10 or 20 person we can't use this method.
🔹To overcom this method we are useing constructor function.

example:

function Student(name, age) {
this.name = name;
this.age = age;
}

This function doesn’t create an object yet it just defines how an object should look.

Explanation of `this`

🔹this refers to the object that is currently being created or operated on.

🔹In the context of a constructor function, this points to the newly created instance of that object.

🔹Creating Objects Using a Constructor

To create an object, we use the new keyword:

let s1 = new Student("Arun", 25);
let s2 = new Student("Bala", 23);

Now you have two separate objects created from the same blueprint.

Screenshot of the program:

What is an Array?

An array is a special type of object used to store multiple values in a single variable.

let numbers = [1, 2, 3];

Basic Array Methods

Arrays come with built-in methods that make data manipulation easy.

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()

(TBD)

Objects in javascript.

Madhavan G — Tue, 07 Apr 2026 15:39:58 +0000

What is an Object in JavaScript?

An object in JavaScript is a collection of data stored in key–value pairs. It helps us group related information together in a structured way.

Example:

let person = {
  name: "Arun",
  age: 22,
  city: "Chennai"
};

Here, name, age, and city are keys, and their corresponding values store information about the person.

Why Are Objects Important?

Without objects, we would store related data in separate variables, making our code messy and harder to manage.

Objects help us:

Organize data efficiently
Represent real-world entities
Write clean and maintainable code

Why Do We Need Objects?

Objects are essential because they allow developers to:

Group related data together
Build scalable applications
Represent complex data structures easily

Common Uses of Objects

Objects are widely used in JavaScript for:

Storing user data
Managing products in e-commerce applications
Handling API responses
Structuring application data

Example:

let product = {
  name: "Laptop",
  price: 50000,
  inStock: true
};

CRUD Operations in Objects

CRUD stands for:

Create
Read
Update
Delete

These are the basic operations we perform on object data.

Step-by-Step Example

1. Create an Object

let user = {
name: "Rahul",
age: 25
};

2. Read Data

console.log(user.name);
console.log(user.age);

screenshot of the program:

3. Update Data

user.name="Maddy"
user.age = 23;

screenshot of the program:

4. Add New Property

user.city = "Chennai";
user.branch="ECE"

screenshot of the program:

5. Delete Property

delete user.branch;

screenshot of the program:

Types of Functions in JavaScript with example and it's Importance.

Madhavan G — Mon, 06 Apr 2026 17:01:48 +0000

JavaScript functions are one of the most powerful features of the language. Over time, different types of functions were introduced to solve specific problems and improve code quality, readability, and flexibility.

So here are the major types of JavaScript functions, their importance, and how they evolved step by step.

1. Function Declaration:

Function declarations are the most basic way to define a function.

function greet(name) {
  return "Hello " + name;
}

Importance:

Simple and easy to understand
Hoisted, so they can be used before declaration
Ideal for general-purpose reusable logic

Why it existed:
JavaScript initially needed a straightforward way to define reusable blocks of code.

2. Function Expression:

A function expression stores a function inside a variable.

const greet = function(name) {
  return "Hello " + name;
};

Importance:

Functions can be treated as values
Can be passed as arguments or returned from other functions

Why it evolved:
Developers needed more flexibility to use functions dynamically.

3. Arrow Function

Introduced in ES6, arrow functions provide a shorter syntax.

const greet = (name) => "Hello " + name;

Importance:

Cleaner and more concise syntax
Inherits this from the surrounding context

Why it evolved:
To reduce boilerplate code and fix common issues with this.

4. Anonymous Function

Anonymous functions do not have a name.

setTimeout(function() {
  console.log("Hello");
}, 1000);

Importance:

Useful for one-time use
Common in callbacks and event handling

Why it evolved:
To avoid unnecessary naming and keep code concise.

5. Named Function Expression

A function expression with a name.

const greet = function sayHello(name) {
  return "Hello " + name;
};

Importance:

Improves debugging (name appears in stack traces)
Useful for recursion

Why it evolved:
To combine flexibility with better readability and debugging.

6. Immediately Invoked Function Expression (IIFE)

Runs immediately after being defined.

(function() {
  console.log("Executed immediately");
})();

Importance:

Creates a private scope
Prevents global variable pollution

Why it evolved:
Before let and const, JavaScript lacked block scope, so IIFE helped manage scope.

7. Callback Function

A function passed as an argument to another function.

function processUser(name, callback) {
  callback(name);
}

Importance:

Essential for asynchronous programming
Used in events, APIs, and timers

Why it evolved:
JavaScript is non-blocking, so callbacks help handle operations that complete later.

8. Higher-Order Function

Functions that take or return other functions.

function operate(a, b, fn) {
  return fn(a, b);
}

Importance:

Enables reusable and modular code
Common in methods like map, filter, and reduce

Why it evolved:
Functional programming concepts influenced JavaScript development.

9. Constructor Function

Used to create objects.

function Person(name) {
  this.name = name;
}

const user = new Person("John");

Importance:

Allows creation of multiple similar objects
Foundation of object-oriented programming in JavaScript

Why it evolved:
To provide a structured way to create and manage objects.

10. Generator Function

Functions that can pause and resume execution.

function* count() {
  yield 1;
  yield 2;
  yield 3;
}

Importance:

Enables controlled iteration
Useful in complex asynchronous flows

Why it evolved:
To handle advanced execution control and simplify async workflows.

Evolution of JavaScript Functions

JavaScript functions didn’t appear all at once—they evolved to solve real-world problems:

Basic Stage → Function Declarations for simple reuse
Flexibility Stage → Function Expressions and Anonymous Functions
Scope Management → IIFE to avoid global pollution
Asynchronous Era → Callback Functions
Code Reusability → Higher-Order Functions
Object-Oriented Programming → Constructor Functions
Modern JavaScript (ES6+) → Arrow Functions and Generators

Types of Functions in Javascript.

Madhavan G — Mon, 06 Apr 2026 05:49:41 +0000

1.Function Declaration
2.Function Expression
3.Arrow Function
4.Anonymous Function
5.Named Function Expression
6.Immediately Invoked Function (IIFE)
7.Callback Function
8.Higher-Order Function
9.Constructor Function
10.Generator Function.

Function in JavaScript.

Madhavan G — Fri, 03 Apr 2026 15:53:30 +0000

What is Functions in JavaScript?

•Functions are reusable code blocks designed for particular tasks,You define it once, and then you can "call"(run) it whenever needed and it can be called multiple times as user want it.

•Functions are executed when they are called.

•Functions are fundamental in all programming languages.

Function Parameters:
•Parameters allow you to send values to a function.

•Parameters are listed in parentheses() in the function definition.

What Does a Function Look Like?

•A function can be created with the function keyword, a name, and parentheses.

•The code to run is written inside curly brackets.

Example:

function addNumbers(a, b)
{
let sum = a + b;
return sum;
}
•The function above does not do anything.
•It has to be called first.

let result = addNumbers(5, 3);
console.log(result);

•Now the above code will run.

What’s happening in this Code:

1. Function Declaration:

⇒function addNumbers(a, b)
•You define a function named addNumbers.
•It takes two parameters: a and b.
•Think of parameters as placeholders or container for values.

2. Function Body Executes When Called:
⇒let sum = a + b;
•Inside the function, a variable sum is created.
•It adds the values of a and b.

3. Returning a Value:
⇒return sum;
•The function sends the result back to wherever it was called.
•Without return, the function would give undefined.

4.Calling the Function:
⇒let result = addNumbers(5, 3);
•The function is called (invoked) with values 5 and 3.
•These values replace a and b:
⇒a = 5
⇒b = 3

5.Execution Inside the Function:
⇒sum = 5 + 3
•sum = 8
•return 8

6.Storing the Result:
⇒let result = 8;
•The returned value (8) is stored in result.

7.Output to Console:
⇒console.log(result);
•Prints: 8

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

Student Performance Evaluation Using Arrays and Loops.

Madhavan G — Thu, 02 Apr 2026 14:40:49 +0000

PROGRAM:
const marks=[96,85,64,94,100];
let i=0;
let failCount=0;
let total=0;
let average=0;
let j=0;
while(i if(marks[i]<35){
fcount++;
}
i++
}
console.log("FailCount",failCount);
if(failCount>0){
console.log("no grade")
}
else{
j=0;
while(j total+=marks[j];
j++;
}
}
console.log("Total",total);
average=Math.floor(total/marks.length);
console.log("Average",average);
if(failCount==0){
if(average>=90){
console.log("grade A");
}
else if(average>=80){
console.log("grade B");
}
else if(average>=70 ){
console.log("grade C");
}
else if(average>=60){
console.log("grade D");
}
else{
console.log("grade E")
}
}
OUTPUT:
FailCount 0
Total 439
Average 87
grade B

FLOWCHART:

EXPLANATION:
Step 1.Assigning vaiables like marks=[96,85,64,94,100],i=0,j=0,total=0,average=0,failCount=0.

Step 2.It checks the while loop condition:
i < marks.length →0 < 5 →true
So, the loop starts.

Step 3.Check marks[i] < 35 → marks[0] = 96 → not less than 35
So, failCount remains 0
Increment i → i = 1.

Step 4.Check 1 < 5 → true
marks[1] = 85 → not less than 35
failCount = 0
Increment i = 2

Step 5.
Check 2 < 5 → true
marks[2] = 64 → not less than 35
failCount = 0
Increment i = 3

Step 6.
Check 3 < 5 → true
marks[3] = 94 → not less than 35
failCount = 0
Increment i = 4

Step 7.
Check 4 < 5 → true
marks[4] = 100 → not less than 35
failCount = 0
Increment i = 5

Step 8.
Check 5 < 5 → false
Exit the loop.

Step 9.
Print:
FailCount 0

Step 10.
Check condition: failCount > 0 → 0 > 0 → false
So, go to else block.

Step 11.
Initialize j = 0
Check j < 5 → 0 < 5 → true

Step 12.
Add marks[0] = 96 → total = 96
Increment j = 1

Step 13.
Check 1 < 5 → true
Add marks[1] = 85 → total = 181
Increment j = 2

Step 14.
Check 2 < 5 → true
Add marks[2] = 64 → total = 245
Increment j = 3

Step 15.
Check 3 < 5 → true
Add marks[3] = 94 → total = 339
Increment j = 4

Step 16.
Check 4 < 5 → true
Add marks[4] = 100 → total = 439
Increment j = 5

Step 17.
Check 5 < 5 → false
Exit loop.

Step 18.
Print:
Total 439

Step 19.
Calculate average:
average = Math.floor(439 / 5) = 87
(Here Math.floor used to avoid decimal values)

Step 20.
Print:
Average 87

Step 21.
Check failCount == 0 → true
So grading starts.

Step 22.
Check conditions:
87 >= 90 → false
87 >= 80 → true
So:
grade B

Final Output (For Given Input):
FailCount 0
Total 439
Average 87
grade B
=== Code Execution Successful ===

ARRAY

Madhavan G — Thu, 02 Apr 2026 07:25:19 +0000

Simple Definition
An array in JavaScript is a special variable used to store multiple values in a single variable.
Example:
let marks = [85, 90, 78, 92];
Here:
1.Marks is an array
2.It contains 4 values
3.Each value has a position (index)

Index:
Array values are stored with index numbers starting from 0
Example:
let fruits = ["apple", "banana", "mango"];

console.log(fruits[0]); // apple
console.log(fruits[1]); // banana
console.log(fruits[2]); // mango

Why we use Arrays

Instead of this ❌:
let a = 10;
let b = 20;
let c = 30;

We use array ✅:
let numbers = [10, 20, 30];
This makes code:
*Cleaner
*Easier to manage
*Faster to work with loops

Key Features:
Can store different data types
let data = [10, "hello", true];
*Dynamic (can grow/shrink)
*Access using index

JavaScript

Madhavan G — Tue, 31 Mar 2026 14:18:52 +0000

WHAT IS JAVASCRIPT?

⇒JavaScript is a high-level programming language mainly used to make websites interactive and dynamic.
⇒It also known as scripting Language.

What JavaScript Does?

⇒It runs in your browser (like Chrome, Edge, etc.) and lets you:
- Update content on a page without reloading
- Handle user actions (clicks, typing)
- Create animations and effects
- Communicate with servers (APIs)

Where JavaScript Is Used?

Frontend (browser)
Buttons, forms, animations
Backend (server-side) using tools like Node.js
Mobile apps (React Native)
Games & desktop apps

Datatypes Javascript:

⇒In JavaScript, data types define what kind of value a variable can hold.

They are mainly divided into two categories:

     I.Primitive Data Types
     II.Non-Primitive Data Types

Primitive Data Types:

1.Numbers
2.String
3.Boolean
4.Undefined
5.Null
6.BigInt
7.Symbol

Non-Primitive Data Types:
1.Object
2.Array
3.Function

Now What is Primitive and Non-Primitive?
Let see:

•Primitive:These are basic,they store the actual value directly and we can't change the value that is immutable values.
•Non-Primitive:These are complex objects that store collections of data and we can change the value that is Mutable values.

What are the keywords in JavaScript?
•In JavaScript, keywords are reserved words that have a special meaning and cannot be used as variable names, function names, or identifiers.

Common JavaScript Keywords:

Variable Declaration:

• var
• let
• const

2.Control Flow (Conditions & Loops):
• if, else, switch, case, default
• for, while, do, break, continue

3.Functions & Return:
• function
• return

4.Object & Class Related:
• class, constructor
• this
• new

5.Error Handling:
• try, catch, finally, throw

6.Modules (Modern JavaScript)
• import, export

7.Other Important Keywords:
• typeof
• instanceof
• delete
• in
• void
• yield
• await
• async

DEV Community: Madhavan G

JavaScript Array Iterations.

JavaScript Callbacks.

JavaScript Explained: From Basics to Data Types and Variables.

WHAT IS JAVASCRIPT?

Array Methods in JavaScript.

what is array in javascript?

Example:

Basic Array Methods in Javascript are:

∗Arraylength:

∗Array toString()

∗Array at()

∗Array join()

∗Array pop()

∗Array push()

∗Array shift()

∗Array unshift()

∗Array.isArray()

∗Array delete (operator)

∗Array concat()

∗Array copyWithin()

∗Array flat()

∗Array slice()

∗Array splice()

∗Array toSpliced()

Constructor function and Basic Array methods.

🔷 What is a Constructor Function?

Example:

example:

Explanation of this

Screenshot of the program:

What is an Array?

Basic Array Methods

(TBD)

Objects in javascript.

What is an Object in JavaScript?

Example:

Why Are Objects Important?

Why Do We Need Objects?

Common Uses of Objects

Example:

CRUD Operations in Objects

Step-by-Step Example

1. Create an Object

2. Read Data

screenshot of the program:

3. Update Data

screenshot of the program:

4. Add New Property

screenshot of the program:

5. Delete Property

screenshot of the program:

Types of Functions in JavaScript with example and it's Importance.

1. Function Declaration:

2. Function Expression:

3. Arrow Function

4. Anonymous Function

5. Named Function Expression

6. Immediately Invoked Function Expression (IIFE)

7. Callback Function

8. Higher-Order Function

9. Constructor Function

10. Generator Function

Evolution of JavaScript Functions

Types of Functions in Javascript.

Function in JavaScript.

Student Performance Evaluation Using Arrays and Loops.

ARRAY

JavaScript

Explanation of `this`