Forem: Nikita Maharana

Array Destructuring Explained

Nikita Maharana — Thu, 14 May 2026 12:43:50 +0000

Array Destructuring means extracting values from arrays and assigning in a convenient way for unpacking array elements into distinct variables.

or Simply, Array destructuring means taking values from an array and storing them into separate variables easily.

e.g:1
let fruits = ["apple", "grapes", "orange"];
let [first, second, third] = fruits;

console.log(first); //'apple'
console.log(second); //'grapes'
console.log(third); //'orange'

e.g:2
Accessing by their index values

let fruits = ["apple", "grapes", "orange"];
let first = fruits[0];
let second = fruits[1];
let third = fruits[2];

console.log(first); //'apple'
console.log(second); //'grapes'
console.log(third); //'orange'

The Rest Syntax: It allows you to capture the remaining elements of an array that have not been destructured into a new array.It's denoted by three dots (...).
e.g:
let fruits = ["apple", "banana", "orange", "grapes", "kiwi"];
let [first, second, ...rest] = fruits;

console.log(first); //'apple'
console.log(second); //'banana'
console.log(rest); //['orange', 'grapes', 'kiwi']

Explained Global, Local & Block Scope in JavaScript

Nikita Maharana — Wed, 13 May 2026 16:54:13 +0000

Scope: Scope generally means the visibility and accessibililty of variables in different parts of your code. Understanding of differnt types of scopes helps us write error free and clear code.

Global Scope:
Global scope means the variable is having its accessibility anywhere in the program, inside function or blocks etc. But sometimes it leads to naming conflicts.
e.g:
let global = "I'm a global variable";
function display(){
console.log(global);
}
display(); // "I'm a global variable"

In this example, global is declared in the global scope and can be accessed inside the display function.

Local Scope:
The variables are only accessible within a function not outside of it.
e.g:
function local(){
var local = "I'm a local scope variable";
if (true){
console.log(local);// Works here also inside of if block
}
}

Block Scope:
The variables are accessed within that block not outside of it.
if (true) {
let block = "I'm a block variable";
console.log(block);// Works here inside of the block only
}
console.log(block);//it will throw an error

Let's try to understand the difference between var, let and const based on Scopes

How to declare variables in JS?
We can declare variables in JS using var, let and const.

A variable is like a container used to store a value.

var is a function scoped variable which can be redeclared and reassigned.
e.g: console.log("Nikita Maharana");
var a = 25;
var a = 3;//can redeclare using var in js
a = 56;//reassigning is possible
console.log(a);

let is a block scoped variable which can be reassigned but cannot be redeclared.
e.g: let x = 9;
// let x = 5;// cannot redeclare
x = 78;//reassigning is also possible using let not re-declare
console.log(x);

const is a block scoped variable which cannot be redeclared or reassigned.
e.g: const y = 11;
// const y = 22; cannot re-declare
//y = 30;//re-assigning is not possible
console.log(y);

So, basically we can say...var is function scoped variable & let and const are block scoped variables.
ex1:
function fun(){
if(true){
var a = 55;
}
console.log(a);//inside the fxn it will work everywhere
}
fun();

ex2:
function fun(){
if(true){
var a = 55;let b = 34;const c = 34
}
console.log(a,b);//inside the fxn it will work everywhere b will not be printed
console.log(c);//c is block scoped it will not be printed
}
fun();

Array Functions Explained Simply

Nikita Maharana — Wed, 13 May 2026 15:20:37 +0000

Array: Arrays are used to store elements. Array is a collection of elements.
eg: let arr = [5, 44, 87, 9]
arr[0] = 5;
arr[1] = 44;

length is a method of array which returns total no of elements in the array.

//Arrays Methods:
i. push: push is used to insert a value into the array as last value
e.g: array.push(values)
ii. pop(): pop is used to remove only the last value of the array
eg: array.pop()

iii. unshift : unshift is used to insert value or values into the array as first value
e.g: array.unshift(values)

iv. shift(): shift is used to remove only starting vlaue of the array
eg: array.shift()

v. splice: splice(starting_index, deleteCount, insertValues)
It is used to delete any number of values or insert any number of values to the array
let arr = [5,4,6,7];
arr.splice(1,1)
arr.splice(1) -- will delete whole array from index 1
arr.splice(1, 2) -- will delete 2 values from index 1
arr.splice(1, 2, "shekhar") -- will delete 2 values from index 1 and add shkhar at index 1

vi. reverse is used to reverse the array.
eg: array.reverse();
arrays are mutable it changes the original array.

vii. includes : includes is used to check whether the value is included in the array or not.

viii. forEach(callback) : forEach is a method of arrays which accepts callback fxns as parameter and will apply the fxn to each and every element of array

Syntax : forEach(value, index)

Closure Explained in JS

Nikita Maharana — Wed, 13 May 2026 08:53:12 +0000

Closure: An inner fxn remembers the outer fxn values even after outer fxn execution gets ended.

We use this in techniques called memorization it means making code able to remember the previous input and its corresponding output such that it will not again calculate for same input.

//CLosure
function outer(){
var x = 25;
function inner() {
x++;//x is not in inner fxn its in outer but it remembers outer value that called memorization or closure
console.log(x);
}
return inner;
}
let result = outer();
console.log(result);
//it calls outer and outer returns inner so whole innner fxn returns
//inner is not yet called so 26 will not be printed as it is seems

result();//inner called 26
result()//27
result()//28 and so on...

Callback Functions in JavaScript Explained

Nikita Maharana — Wed, 13 May 2026 08:22:18 +0000

Callback Functions

A callback function is a function which is passed as an argument to another function.

e.g. function kind(){
console.log("I'm kind");
}
function rude(){
console.log("I'm rude");
}
function fun(a, b){
a();//calls kind()
b();//calls rude()
}
fun(kind, rude);

//Output:
I'm kind
I'm rude

Here, kind and rude are callback functions because they are passed as arguments to another function named as fun.
And fun is called a higher order function because it accepts functions (kind and rude) as parameters.