DEV Community: G Gokul

ARRAY SEARCH METHODS IN JAVASCRIPT

G Gokul — Tue, 21 Jul 2026 10:49:08 +0000

Array Search Methods:

JavaScript Array indexOf()
The indexOf() method searches an array for an element value and returns its position.

Syntax:
array.indexOf(item, start)

example:
const fruits = ["Apple", "Orange", "Apple", "Mango"]; let position = fruits.indexOf("Apple"); console.log(position); console.log(fruits);

output:
0
[ "Apple", "Orange", "Apple", "Mango" ]

example:
const fruits = ["Apple", "Orange", "Apple", "Mango"]; let position = fruits.indexOf("Apple",3); console.log(position);

output:
-1 (Array.indexOf() returns -1 if the item is not found.)

JavaScript Array lastIndexOf()

Array.lastIndexOf() is the same as Array.indexOf(), but returns the position of the last occurrence of the specified element.

syntax:
array.lastIndexOf(item, start)

example:
const fruits = ["Apple", "Orange", "Apple", "Mango"];
let position1 = fruits.lastIndexOf("Apple",1);
console.log(position1);

output:
0

example:
const fruits = ["Apple", "Orange", "Apple", "Mango"];
let position1 = fruits.lastIndexOf("Apple");
console.log(position1);

output:
2

JavaScript Array includes()

This allows us to check if an element is present in an array (including NaN, unlike indexOf).

syntax:
array.includes(search-item)

example:
const fruits1 = ["Banana", "Orange", "Apple", "Mango"]; console.log(fruits1.includes("Mango")); console.log(fruits1.includes("kiwi"));

output:
true
false

JavaScript Array find()

The find() method returns the value of the first array element that passes a test function.

example:
const numbers = [4, 9, 16, 25, 29]; let first = numbers.find(myFunction); function myFunction(value, index, array) { return value > 18; } console.log(first); console.log(numbers);

output:
25
[ 4, 9, 16, 25, 29 ]

JavaScript Array findIndex()

The findIndex() method returns the index of the first array element that passes a test function.

example:
const numbers1 = [4, 9, 16, 25, 29]; let first1 = numbers1.findIndex(myFunction1); function myFunction1(value, index, array) { return value > 18; } console.log(first1); console.log(numbers1);

output:
3

[ 4, 9, 16, 25, 29 ]

JavaScript Array findLast() Method

findLast() method that will start from the end of an array and return the value of the first element that satisfies a condition.

example:
const temp = [27, 28, 30, 40, 42, 35, 30]; let high = temp.findLast(x => x < 40); console.log(high); console.log(temp);

output:
30
[ 27, 28, 30, 40, 42, 35, 30 ]

JavaScript Array findLastIndex() Method

The findLastIndex() method finds the index of the last element that satisfies a condition.

example:
const temp = [27, 28, 30, 40, 42, 35, 30]; let pos = temp.findLastIndex(x => x > 40); console.log(pos); console.log(temp);

output:
4
[ 27, 28, 30, 40, 42, 35, 30 ]

ARRAY ITERATIONS IN JAVASCRIPT PART-3

G Gokul — Tue, 21 Jul 2026 10:08:57 +0000

JavaScript Array Iterations:

JavaScript Array flatMap()

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

example:
const numbers = [1, 2, 3, 4]; const result = numbers.flatMap(num => { if (num % 2 === 0) { return [num, num * 10]; } else { return []; } }); console.log(result);

output:
[ 2, 20, 4, 40 ]

JavaScript Array filter()

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

example:
const numbers1 = [45, 4, 9, 16, 25]; const less18 = numbers1.filter(myFunction); function myFunction(value) { return value < 18; } console.log(less18);

output:
[4,9,16]

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.

example:
const numbers = [45, 4, 9, 16, 25]; let sum = numbers.reduce(myFunction); function myFunction(total, value) { return total / value; } console.log(sum);

output:
0.003125

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.

example:
const numbers = [45, 4, 9, 16, 25]; let sum1 = numbers.reduceRight(myFunction); function myFunction(total, value) { return total - value; } console.log(sum1);

output:
-49

JavaScript Array every()

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

example:
const numbers = [45, 4, 9, 16, 25]; let allOver18 = numbers.every(myFunction); function myFunction(value) { return value > 18; }

output:
false

JavaScript Array some()

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

example:
const numbers = [45, 4, 9, 16, 25]; let someOver18 = numbers.some(myFunction); function myFunction(value, index, array) { return value > 18; }

output:
true

JavaScript Array.from()

The Array.from() method returns an Array object from:
Any iterable object
Any object with a length property

example:
let text = "GOKULGANAPATHY"; let name = Array.from(text); console.log(name);

output:
[ "G", "O", "K", "U", "L", "G", "A", "N", "A", "P","A","T","H","Y"]

JavaScript Array keys()(TBD)

The Array.keys() method returns an Array Iterator object with the keys of an array.

example:
const fruits = ["Banana", "Orange", "Apple", "Mango"]; const keys = fruits.keys(); for (let x of keys) { console.log(x); } console.log(keys)

output:
0
1
2
3
Array Iterator { constructor: Iterator() }

JavaScript Array entries()(TBD)

The entries() method returns an Array Iterator object with key/value pairs.

example:
const fruits1 = ["Banana", "Orange", "Apple", "Mango"]; const f = fruits1.entries(); for (let x of f) { console.log(x); } console.log(f);

output:
[ 0, "Banana" ]
[ 1, "Orange" ]
[ 2, "Apple" ]
[ 3, "Mango" ]
Array Iterator { constructor: Iterator() }

JavaScript Array with() Method

the Array with() method as a safe way to update elements in an array without altering the original array.

example:
const months = ["January", "February", "March", "April"]; const myMonths = months.with(2, "august"); console.log(myMonths); console.log(months);

output:
[ "January", "February", "august", "April" ]
[ "January", "February", "March", "April" ]

JavaScript Array Spread (...)

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

example:
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]; console.log(year); console.log(q3);

output:
[ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
[ "Jul", "Aug", "Sep" ]

JavaScript Array Rest (...)

The rest operator (...) allows us to destruct an array and collect the leftovers.

example:
let a, b, rest; const arr1 = [1, 2, 3, 4, 5, 6, 7, 8]; [a, b, ...rest] = arr1; console.log(a); console.log(b); console.log(rest); console.log(arr1);

output:
1
2
[ 3, 4, 5, 6, 7, 8 ]
[ 1, 2, 3, 4, 5, 6, 7, 8 ]

References:

w3schools.com

ARRAY ITERATIONS IN JAVASCRIPT PART-2

G Gokul — Mon, 20 Jul 2026 13:15:14 +0000

Difference between forEach() and map():

example:
const numbers = [45,10,25,30,60]; function display (value, index, array ){ return value * 2; } const forEachReturn = numbers.forEach(display); const MapReturn = numbers.map(display); console.log(forEachReturn); console.log(MapReturn) console.log(numbers);

output:
undefined
[ 90, 20, 50, 60, 120 ]
[ 45, 10, 25, 30, 60 ]

example:
const numbers2 = [1, 2, 3]; const resultForEach = numbers2.forEach(num => num * 2); console.log(resultForEach); const resultMap = numbers2.map(num => num * 2); console.log(resultMap);

output:
undefined
[ 2, 4, 6 ]

example:
const users = [ { id: 1, name: "Sam" }, { id: 2, name: "Alex" } ]; const usernames = users.map(user => user.name); console.log(usernames); const username = users.forEach(user => user.name); console.log(username)

output:
Array [ "Sam", "Alex" ]
undefined

example:
(TBD)
const sparseArr = [1, , 3, , 5]; sparseArr.forEach(n => console.log(n)); const mapped = sparseArr.map(n => n * 2); console.log(mapped);

output:
1
3
5
[ 2, <1 empty slot>, 6, <1 empty slot>, 10 ]

ARRAY ITERATIONS IN JAVASCRIPT

G Gokul — Fri, 17 Jul 2026 08:51:21 +0000

Iteration in javascript:

Iteration in JavaScript refers to repeatedly executing a block of code over a sequence of values, such as arrays, objects, or other iterable structures.
JavaScript offers multiple loop constructs, array iteration methods, and iterator protocols to handle different scenarios efficiently.

Array Iteration Methods:

Array iteration methods operate on every array item.
In JavaScript, array iteration methods are built-in functions that allow you to loop through (iterate over) each element of an array and perform some operation on them without manually writing a for loop.
These methods make code shorter, cleaner, and more readable.

1. The for...of Loop:

The for...of statements hands you the array values.

Example:
const cars =["bmw","volvo","mini"]; for (let car of cars){ console.log(car); }

output:
bmw
volvo
mini

2. The for...in Loop:

The for...in statements hands you the array indexes.

Example:
const cars =["bmw","volvo","mini"]; for (let car in cars){ console.log(car) }

output:
0
1
2

3. JavaScript Array forEach():

The forEach() method calls a function (a callback function) for each array element.
the function takes 3 arguments:

The item value
The item index
The array itself

Example:
const numbers = [45,4,9,12,15]; numbers.forEach(display); function display(value,index,array){ console.log(value, index, array) }

output:
45 0 (5) [45, 4, 9, 12, 15]
4 1 (5) [45, 4, 9, 12, 15]
9 2 (5) [45, 4, 9, 12, 15]
12 3 (5) [45, 4, 9, 12, 15]
15 4 (5) [45, 4, 9, 12, 15]

Callback function:

A callback function in JavaScript is a function that is passed as an argument to another function and is executed later, usually after some operation has completed or when an event occurs.
Callbacks are commonly used for:

Asynchronous operations (e.g., reading files, making API calls)
Event handling (e.g., button clicks)
Customizable function behavior

Types of callbacks:

Synchronous Callbacks:

Executed immediately during the execution of the function they are passed to.
Commonly used in array methods like .map(), .filter(), .forEach().

example:
function greet(callback) { console.log("Hello "); callback(); } function sayBye() { console.log("Goodbye!"); } greet(sayBye);

output:
Hello
Goodbye!

Asynchronous Callbacks:

Executed later, often after an operation completes (e.g., timers, API calls, file reading).
Common in event handling and I/O operations.

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

example:
const num = [45, 4, 9, 12, 15]; num.map(display); function display(value, index, array) { console.log(value, index, array) } console.log(num);

output:
45 0 Array(5)
4 1 Array(5)
9 2 Array(5)
12 3 Array(5)
15 4 Array(5)

Differences between forEach() and map() methods:

(TBD)

Reference:

w3schools.com

BASIC ARRAY METHODS IN JAVASCRIPT

G Gokul — Thu, 16 Jul 2026 17:06:42 +0000

Basic Array Methods

JavaScript Array length:

the length property returns the length (size) of an array.
The length property can also be used to set the length of an array.

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

Output:
4
[ 'Banana', 'Orange' ]

JavaScript Array toString():

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

Example:
const fruits = ["Banana", "Orange", "Apple", "Mango"]; console.log(fruits.toString());
Output:
Banana,Orange,Apple,Mango

JavaScript Array at():

The at() method returns an indexed element from an array.
The at() method returns the same as [].

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

Output:
Apple

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"]; console.log(fruits.join("*"));

Output:
Banana*Orange*Apple*Mango

JavaScript Array pop():

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

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

Output:
Mango
[ 'Banana', 'Orange', 'Apple' ]

JavaScript Array push()

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

Example:
const fruits = ["Banana", "Orange", "Apple", "Mango"]; console.log(fruits.push("Kiwi")); console.log(fruits)
Output:
5
[ 'Banana', 'Orange', 'Apple', 'Mango', 'Kiwi' ]

JavaScript Array shift()

The shift() method removes the first array element and "shifts" all other elements to a lower index.
The shift() method returns the value that was "shifted out".

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

Output:
Banana
[ 'Orange', 'Apple', 'Mango' ]

JavaScript Array unshift()

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

Example:

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

Output:
5
[ 'Lemon', 'Banana', 'Orange', 'Apple', 'Mango' ]

Array.isArray()
Example:
const fruits = ["Banana", "Orange", "Apple", "Mango"]; console.log(Array.isArray(fruits));

Output:
True

JavaScript Array delete()

Using delete() leaves undefined holes in the array.
Use pop() or shift() instead.

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

Output:
true
[ <1 empty item>, 'Orange', 'Apple', 'Mango' ]

JavaScript Array concat()

The concat() method creates a new array by merging (concatenating) existing arrays.
The concat() method does not change the existing arrays. It always returns a new array.
The concat() method can take any number of array arguments.
The concat() method can also take strings as arguments.

Example:
const myGirls = ["Cecilie", "Lone"]; const myBoys = ["Emil", "Tobias", "Linus"]; const myChildren = myGirls.concat(myBoys); console.log(myChildren)

Output:
['Cecilie', 'Lone', 'Emil', 'Tobias', 'Linus' ]

Array copyWithin()

The copyWithin() method copies array elements to another position in an array.
The copyWithin() method overwrites the existing values.
The copyWithin() method does not add items to the array.
The copyWithin() method does not change the length of the array.

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

Output:
['Banana', 'Orange', 'Banana', 'Orange', 'Kiwi' ]

JavaScript Array flat()

The flat() method creates a new array with sub-array elements concatenated to a specified depth.

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

Output:
[1, 2, 3, 4, 5, 6 ]

JavaScript Array flatMap()

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]); console.log(newArr)

Output:
[
1, 10, 2, 20, 3,
30, 4, 40, 5, 50,
6, 60
]

JavaScript Array splice()

The splice() method can be used to add new items to an array.
The first parameter (2) defines the position where new elements should be added (spliced in).
The second parameter (0) defines how many elements should be removed.
The rest of the parameters ("Lemon" , "Kiwi") define the new elements to be added.

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

Output:
[]
['Banana', 'Orange', 'Lemon', 'Kiwi', 'Apple', 'Mango' ]

JavaScript Array toSpliced()

The difference between the new toSpliced() method and the old splice() method is that the new method creates a new array, keeping the original array unchanged, while the old method altered the original array.

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

Output:
['Mar', 'Apr' ]

JavaScript Array slice()

The slice() method slices out a piece of an array into a new array.
The slice() method creates a new array.
The slice() method does not remove any elements from the source array.

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

Output:
[ 'Orange', 'Lemon' ]
[ 'Banana', 'Orange', 'Lemon', 'Apple', 'Mango' ]

ARRAYS IN JAVASCRIPT

G Gokul — Wed, 15 Jul 2026 11:53:37 +0000

Arrays in js:

An Array is an object type designed for storing data collections.
An array is a list of values, known as elements.
Array elements are ordered based on their index.
The first element is at index 0, the second at index 1, and so on.
Arrays can grow or shrink as elements are added or removed.

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

1. Create Array using Literal:

Creating an array using array literal involves using square brackets [] to define and initialize the array.

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

2. Create using new Keyword (Constructor):(TBD)

The "Array Constructor" refers to a method of creating arrays by invoking the Array constructor function.

example:
let a = new Array(10, 20, 30); console.log(a);
output:
[10, 20, 30]

Basic Operations on JavaScript Arrays:

(TBD)

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.

example:
let k = ["HTML", "CSS", "JS"]; console.log(k[0]); console.log(k[1]);
output:
html css

2. Modifying the Array Elements:

Elements in an array can be modified by assigning a new value to their corresponding index.

example:
let g = ["HTML", "CSS", "JS"]; console.log(g); g[1] = "Bootstrap"; console.log(g);
output:
['HTML', 'CSS', 'JS'] ['HTML', 'Bootstrap', 'JS']

3. Adding Elements to the Array:

Elements can be added to the array using methods like push() and unshift().
The push() method add the element to the end of the array.
The unshift() method add the element to the starting of the array.

example:
let a = ["HTML", "CSS", "JS"]; a.push("Node.js"); a.unshift("Web Development"); console.log(a);
output:
["Web Development","HTML","CSS","JS","Node.js"]

4. Removing Elements from an Array:(TBD)

To remove the elements from an array we have different methods like pop(), shift(), or splice().
The pop() method removes an element from the last index of the array.
The shift() method removes the element from the first index of the array.
The splice() method removes or replaces the element from the array.

example:
// Creating an Array and Initializing with Values let m = ["HTML", "CSS", "JS"]; console.log(m); // Removes and returns the last element let lst = m.pop(); console.log(m); // Removes and returns the first element let fst = m.shift(); console.log(m); // Removes 2 elements starting from index 1 m.splice(1, 2); console.log(m);
output:
['HTML', 'CSS', 'JS'] ['HTML', 'CSS'] ['CSS'] ['CSS']

5. Array Length:

We can get the length of the array using the array length property.

example:
// Creating an Array and Initializing with Values
let a = ["HTML", "CSS", "JS"]; let len = a.length; console.log("Array Length: " + len);
output:
Array Length: 3

6. Iterating Through Array Elements:

example:
let z = ["HTML", "CSS", "JS"]; for (let i = 0; i < z.length; i++) { console.log(z[i]) }
output:
html css js

OBJECTS IN JAVASCRIPT PART-2

G Gokul — Tue, 14 Jul 2026 12:48:02 +0000

CRUD operations in JS:

CRUD operations in JavaScript allow you to Create, Read, Update, and Delete data.
These operations are fundamental for managing data in applications.

1. Create:
To create an object or add properties to an existing object:
example:
const user = { name: "John", age: 30 }; user.email = "john@example.com"; console.log(user);
output:
{name: 'John', age: 30, email: 'john@example.com'}

2. Read:
To access properties of an object:
example:
const user = { name: "John", age: 30, email: "john@example.com" }; // Using Dot Notation console.log(user.name); // Using Bracket Notation console.log(user["email"]); // Destructuring(TBD) const { name, age } = user; console.log(name, age);
output:
John john@example.com John 30

3. Update:
To modify existing properties:
example:
const user = { name: "John", age: 30, email: "john@example.com" }; user.age = 35; user["email"] = "john.doe@example.com"; console.log(user);
output:
{name: 'John', age: 35, email: 'john.doe@example.com'}

4. Delete:
To remove properties from an object:
example:
const user = { name: "John", age: 30, email: "john@example.com" }; delete user.email; console.log(user);
output:
{name: 'John', age: 30}

CONSTRUCTORS:

In JavaScript, a constructor is a special function used to create and initialize objects.
It’s typically used with the new keyword to produce multiple objects of the same type.
constructor function names start with an uppercase letter.
this inside the constructor refers to that new current object.
This approach is useful when you need to create many objects with similar properties and methods.

example:
function Laptop(price,brand,storage,ram){ this. price = price; this. brand = brand; this. storage = storage; this. ram = ram; } const hp01 = new Laptop(40000,"hp",512,8); const lenovol1 = new Laptop(50000,"lenovo",1000,16); const asusvivobook = new Laptop(48000,"asus",516,16); const delld5 = new Laptop(45000,"dell",256,8); console.log(hp01); console.log(asusvivobook.ram); console.log(lenovol1["price"])
output:
Laptop {price: 40000, brand: 'hp', storage: 512, ram: 8} 16 50000

HOISTING AND OBJECTS IN JAVASCRIPT

G Gokul — Mon, 13 Jul 2026 13:38:06 +0000

Hoisting:

Hoisting refers to the behavior where JavaScript moves the declarations of variables, functions, and classes to the top of their scope during the compilation phase.
This can sometimes lead to surprising results, especially when using var, let, const, or function expressions.
Hoisting applies to variable and function declarations.
Initializations are not hoisted, they are only declarations.
'var' variables are hoisted with undefined, while 'let' and 'const' are hoisted but remain in the Temporal Dead Zone until initialized.

Temporal Dead Zone (TDZ):

The Temporal Dead Zone (TDZ) is the period in JavaScript between entering a scope and the initialization of variables declared with let or const, during which accessing them results in an error.
Variables declared with let and const are hoisted but not initialized.
Accessing these variables before their declaration throws a ReferenceError.

example:
hello(); var hello = function() { console.log("Hi!"); };
output:
TypeError: hello is not a function

1. Variable Hoisting with var:

When you use var to declare a variable, the declaration is hoisted to the top, but its value is not assigned until the code execution reaches the variable’s initialization.
This results in the variable being assigned undefined during the hoisting phase.

example:
console.log(a); var a = 5;
output:
undefined

2. Variable Hoisting with let and const:

Unlike var, let and const are also hoisted, but they remain in a Temporal Dead Zone (TDZ) from the start of the block until their declaration is encountered.
Accessing them before their declaration will throw a ReferenceError.

example:
console.log(b); let b = 10;
output:
Uncaught ReferenceError: Cannot access 'b' before initialization

3. Function Declaration Hoisting:

Function declarations are hoisted with both their name and the function body.
This means the function can be called before its definition in the code.

example:
greet(); function greet() { console.log("Hello, Mahima!"); }
output:
Hello, Mahima!

Objects in JS:

In JavaScript, an object is a collection of key–value pairs where keys (also called properties) are strings or symbols, and values can be any data type (including other objects or functions).
Objects are used to store structured data and represent real-world entities.
Values are stored as key:value pairs called properties.
Functions are stored as key:function() pairs called methods.
Objects are mutable and dynamic properties can be added, modified, or deleted at any time.
Objects allow data grouping and encapsulation, making it easier to manage related information and behaviour together.

There are two primary ways to create an object in JavaScript:

1.Creation Using Object Literal:

The object literal syntax allows you to define and initialize an object with curly braces {}, setting properties as key-value pairs.

example:
let obj = { name: "Sourav", age: 23, job: "Developer" }; console.log(obj);
output:
{"name":"Sourav","age":23,"job":"Developer"}

2. Creation Using new Object() Constructor:

(TBD)

Properties:

Values are stored as key:value pairs called properties.
Definition: A property is a key–value pair inside an object.
Key: Always a string (or symbol).
Value: Can be any data type (string, number, boolean, object, array, function, etc.).

example:
const mobile1={ name : "realme", price : 45000, storage : { ram : 8, rom : 256 } } console.log(mobile1) console.log(mobile1.storage.ram)
output:
name: "realme" price: 45000 storage: ram: 8 rom:256 8
Adding/Updating properties:(TBD)
Deleting properties:(TBD)

Methods:

Functions are stored as key:function() pairs called methods.
Definition: A method is a function stored as a property.
Purpose: To define behavior for the object.

example:
const mobile2 = { name: "realme", price: 45000, storage: { ram: 8, rom: 256 }, browse:function(){ console.log("5g networking speed") } } mobile2.browse();
output:
5g networking speed

References:

Objects in JavaScript - GeeksforGeeks

Your All-in-One Learning Portal: GeeksforGeeks is a comprehensive educational platform that empowers learners across domains-spanning computer science and programming, school education, upskilling, commerce, software tools, competitive exams, and more.

geeksforgeeks.org

w3schools.com

FUNCTIONS IN JAVASCRIPT

G Gokul — Sun, 12 Jul 2026 15:50:11 +0000

Functions:

Functions are one of the fundamental building blocks in JavaScript.
In JavaScript, a function is a reusable block of code designed to perform a specific task.
It can take inputs (parameters), process them, and optionally return an output.
Functions help in organizing code, improving reusability, and making programs modular.

How function works in js:

1. Function Declaration:

A function must be defined before it can be used.

2. Function Execution:

Creates a new execution context.
Passes arguments to parameters.
Executes the function body line by line.
Returns the result (or undefined if no return).

Why use functions:

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) { console.log("Hello " + name); } greet("Alice");
output:
Hello Alice
Parameter: name (placeholder inside the function).
Argument: "Alice" (real value given at call time).

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.

example:
function add(a, b) { return a + b; // returns the sum } let result = add(5, 10); console.log(result);
output:
15

Function Expression:

A function expression is a function created as part of an expression and assigned to a variable or passed to another function.
It can be named or anonymous.

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

Arrow Function:

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.

example:
const square = n => n * n; console.log(square(4));
output:
16

References:

developer.mozilla.org

Functions in JavaScript - GeeksforGeeks

geeksforgeeks.org

LOOPING IN JAVASCRIPT

G Gokul — Sun, 12 Jul 2026 15:08:52 +0000

Looping:

Loops in JavaScript are essential for executing a block of code repeatedly based on a specified condition.
They are powerful tools for automating tasks and streamlining your code.
JavaScript supports several types of loops, each suited for different scenarios.
Loops continue running until the condition becomes false.
They are useful for iterating over arrays, strings, and ranges of values.

Types of Loops:

1. for Loop:

The for loop is one of the most commonly used loops in JavaScript.
It provides a concise way of writing the loop structure by including initialization, condition, and increment/decrement in one line.

syntax:
for (initialization; condition; increment/decrement) { // Code to execute}

Flowchart:

example:
for (let i = 0; i < 5; i++) { console.log("Hello World!"); }
output:
Hello World! Hello World! Hello World! Hello World! Hello World!

2. while Loop:

The while loop executes its statements as long as a specified condition evaluates to true.
It is useful when the number of iterations is not known beforehand.

syntax:
while (condition) { // Code to execute }

Flowchart:

example:
let i = 1; let givenno = 54; let count = 0; while(i<=givenno){ if(givenno % i == 0){ count = count + 1; } i++; } console.log(count)
output:
8

3. do...while Loop:

The do-while loop is similar to the while loop, but it checks the condition after executing the statements.
This ensures that the loop executes at least once.

syntax:
do { // Code to execute } while (condition);

Flowchart:

example:
let num = 1; do { console.log(num); num++; } while (num <= 5);
output:
1 2 3 4 5

4. for...of Loop:(TBD)
5. for...in Loop:(TBD)
6. Breaking & Skipping:(TBD)

References:

JavaScript Loops - GeeksforGeeks

geeksforgeeks.org

w3schools.com

CONDITIONAL STATEMENTS IN JAVASCRIPT

G Gokul — Sun, 12 Jul 2026 14:38:56 +0000

Conditional Statements:

In JavaScript, conditional statements control the program flow by executing specific blocks of code based on whether a condition evaluates to true or false.
They are essential for decision-making in scripts, enabling dynamic and interactive behavior.
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) { // block of code to be executed if the condition is true }

example:
let mark = 35; if(mark>=35){ console.log("pass") }
output:
pass

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.

syntax:
if (condition) { // block of code to be executed if the condition is true } else { // block of code to be executed if the condition is false }

example:
let age = 17; if(age>=18){ console.log("eligible to vote") }else{ console.log("not eligible to vote") }
output:
not eligible to vote

3. if...else if...else Ladder:

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.

syntax:
if (condition1) { // block of code to be executed if condition1 is true } else if (condition2) { // block of code to be executed if the condition1 is false and condition2 is true } else { // block of code to be executed if the condition1 is false and condition2 is false }

example:
let score = 75;
if (score >= 90) {
console.log("Grade: A");
} else if (score >= 75) {
console.log("Grade: B");
} else if (score >= 50) {
console.log("Grade: C");
} else {
console.log("Grade: F");
}
output:
Grade: B

4. switch Statement:

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.

syntax:
switch(expression) { case x: // code block break; case y: // code block break; default: // code block }

example:
let day = 3; switch (day) { case 1: console.log("Monday"); break; case 2: console.log("Tuesday"); break; case 3: console.log("Wednesday"); break; case 4: console.log("Thursday"); break; case 5: console.log("Friday"); break; case 6: console.log("Saturday"); break; case 7: console.log("Sunday"); break; default: console.log("Invalid day"); }
output:
Wednesday

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

syntax:
(condition) ? expression1 : expression2

example:
let age = 18; let message = (age >= 18) ? "Eligible to vote" : "Not eligible"; console.log(message);
output:
Eligible to vote

6. Nested if...else:

A nested if...else statement is an if...else block written inside another if or else.
It is used to evaluate multiple related conditions in a hierarchical manner.
Useful for handling complex decision-making logic.
Deep nesting should be avoided to maintain code readability.

example:
let tam = 37; let eng = 45; let mat = 67; let sci = 56; let soc = 77; let total; let avg; if (tam>=35 && eng>=35 && mat>=35 && sci>=35 && soc>=35){ console.log("pass") total = (tam + eng + mat + sci + soc); console.log(total) avg = total/5; console.log(avg) if (avg>=70){ console.log("grade a"); }else if(avg>=50){ console.log("grade b") }else{ console.log("grade c") } }else{ console.log("fail"); }
output:
pass 282 56.4 grade b

References:

JavaScript - Conditional Statements - GeeksforGeeks

geeksforgeeks.org

https://www.w3schools.com/js/js_switch.asp

OPERATORS IN JAVASCRIPT

G Gokul — Sun, 12 Jul 2026 08:58:41 +0000

Operators in JS:

In JavaScript, operators are symbols or keywords used to perform operations on values (operands).
They are the building blocks of expressions and allow you to manipulate data, perform calculations, compare values, and control logic.
Operators fall into three arities based on how many operands they take:
Binary takes two operands, one on each side: a + b, x === y
Unary takes a single operand, before or after: typeof x, x++
Ternary takes three operands: condition ? a : b

Types of Operators in JS:

JavaScript provides a variety of operators to perform actions on values and variables, and data types to represent different kinds of values.

1. Arithmetic Operators:

Arithmetic Operators perform mathematical calculations like addition, subtraction, multiplication, division, remainder, increment, decrement,exponentiation etc.

example:
let x = 5; console.log("Addition: x + 3 = ", x + 3); console.log("Subtraction: x - 3 =", x - 3); console.log("Multiplication: x * 3 =", x * 3); console.log("Division: x / 3 =", x / 3); console.log("Remainder: x % 3 =", x % 3); console.log("Increment: ++x =", ++x); console.log("Decrement: --x =", --x); console.log("Exponentiation: x ** 3 =", x ** 3);
output:
Addition: x + 3 = 8 Subtraction: x - 3 = 2 Multiplication: x * 3 = 15 Division: x / 3 = 1.6666666666666667 Remainder: x % 3 = 2 Increment: ++x = 6 Decrement: --x = 5 Exponentiation: x ** 3 = 125

2. Assignment Operators:

Assignment operators are used to assign values to variables.
They can also perform operations like addition or multiplication while assigning the value.
For example: a += 5 -> a = a + 5.

example:
let a = 7; console.log(a); a += 5; console.log(a); a -= 5; console.log(a); a *= 2; console.log(a); a /= 2; console.log(a); a %= 2; console.log(a); a **= 2; console.log(a);
output:
7 12 7 14 7 1 1

3. Comparison Operators:

Comparison operators compare two values and return a boolean (true or false).
They are useful for making decisions in conditional statements.
Loose equality (==)
Checks whether two values are equal after type coercion. JavaScript converts operand types before comparing.
Strict equality (===)
Checks value and type. No coercion happens. Prefer === in almost every situation because loose equality produces counterintuitive results.
Loose inequality (!=)
Returns true if the values are not equal after coercion.
Greater than (>) and greater than or equal (>=)
Less than (<) and less than or equal (<=)

example:
console.log(2 == 2); console.log(3 != 3); console.log(2 === '2'); console.log(2 !== '2'); console.log(3 > 3); console.log(2 > 2); console.log(3 >= 3); console.log(2 <= 2);
output:
true false false true false false true true

4. Logical Operators:

Logical operators are mainly used to perform the logical operations that determine the equality or difference between the values.
&& returns true if both operands are true.
|| returns true if at least one operand is true.
! negates the boolean value.

example:
let age = 20; console.log(age > 18 && age < 30); console.log(age > 18 || age > 30); console.log(!(age > 18));
output:
true true false

5. Bitwise Operators:(TBD)

Bitwise operators perform operations on binary representations of numbers.
& performs AND operation on each bit.
| performs OR operation on each bit.
^ performs XOR (exclusive OR) on each bit.
~ inverts all bits (NOT operator).
<< shifts bits to the left.
>> shifts bits to the right (with sign).
>>> shifts bits to the right (without sign).

6. Ternary Operator:

A ternary operator evaluates a condition and executes a block of code based on the condition.
The ternary operator evaluates the test condition.
If the condition is true, expression1 is executed.
If the condition is false, expression2 is executed.
The ternary operator takes three operands, hence, the name ternary operator.
It is also known as a conditional operator.

syntax:
condition ? expression1 : expression2
example:
let marks = 45; let result = marks>35 ? "pass" : "fail"; console.log(result)
output:
pass

7. Type Operators:

typeof → Returns the type of a variable.
instanceof → Checks if an object is an instance of a class.(TBD)

example:
console.log(typeof "Hello"); console.log([1,2,3] instanceof Array);
output:
string true

References:

JavaScript Operators - GeeksforGeeks

geeksforgeeks.org

programiz.com

All JS Operators in one guide | CodeForGeek

JS operators are the symbols and keywords that let you do something meaningful with values: add two numbers, compare a user's input, check if an object has a

codeforgeek.com