Forem: Azhar Ahmed A

Hi Everyone checkout my post on understanding variable in javascript

Azhar Ahmed A — Wed, 19 Mar 2025 09:33:19 +0000

Understanding var, let and const in Javascript

Azhar Ahmed A ・ May 14 '22

#javascript #webdev #javascriptbasics #beginners

Understanding JavaScript Closures: A Hidden Gem

Azhar Ahmed A — Wed, 19 Mar 2025 09:30:37 +0000

JavaScript is a versatile language with many powerful features. One such feature, often overlooked by beginners, is closures. Closures are a fundamental concept that can greatly enhance your coding skills and understanding of JavaScript.

What is a Closure?
A closure is a function that retains access to its lexical scope, even when the function is executed outside that scope. In simpler terms, a closure allows a function to access variables from its parent scope, even after the parent function has finished executing.

Why are Closures Important?
Closures are crucial for several reasons:

Data Privacy: Closures enable the creation of private variables. This is useful for encapsulating data and preventing it from being accessed or modified directly.
Function Factories: They allow you to create functions dynamically, with each function having its own scope.
Event Handlers: Closures are often used in event handlers to maintain state.
Example of a Closure
Let's look at a simple example to illustrate closures:

function createCounter() {
  let count = 0;

  return function() {
    count++;
    console.log(count);
  };
}

const counter = createCounter();
counter(); // Output: 1
counter(); // Output: 2

In this example, createCounter returns a function that increments and logs the count variable. Even though createCounter has finished executing, the returned function still has access to count due to the closure.

Practical Use Cases
Encapsulation: Closures are perfect for encapsulating functionality and creating modules.
Memoization: They can be used to store results of expensive function calls and reuse them.
Callbacks: Closures are commonly used in asynchronous programming for callbacks.
Conclusion
Closures are a powerful feature in JavaScript that can help you write more efficient and maintainable code. By understanding and utilizing closures, you can unlock new possibilities in your JavaScript programming journey.

Understanding var, let and const in Javascript

Azhar Ahmed A — Sat, 14 May 2022 19:07:23 +0000

Variables play an important part in any Programming Language as they act as the containers to store the Data
Variables are pretty much required to perform any operation

Javascript provides three ways of declaring the variables namely:
1) var
2) let
3) const

let's explore each variable type and its use cases.

Var:

var declarations were predominant before the advent of ES6.

var greetings = 'Hello Javascript'

It is one of the easiest ways to declare the variables.
var variables can be re-declared and re-initialized.

However, there are issues with the variables declared using var and which led to new ways of variable declarations

Scope of var:

Scope essentially means where the variable is available to be accessed. Variables declared as var are global scoped or function/local scoped.

var globalVar = 'Welcome to my blog';

function readBlog() {
  var localVar = 'You are reading Crazy Js';
}

console.log(globalVar); // 'Welcome to my blog'
console.log(localVar); // Reference Error: localVar is not defined

Here, the variable globalVar can be accessed anywhere across the program as it does not reside inside any function and is a globally scoped variable.

whereas the localVar declared inside the function cannot be accessed outside.

Issues with var

Variables can be re-declared and re-initialized with var:

When a variable is declared using var it can be re-declared and its value can be modified.

var greetings = 'Hello World!';
var greetings = 'Hello Javascript';

as the variable with the same name is redeclared in the same scope it confuses.

Hoisting in var:

Variables declared as var can be accessed before they are declared this is possible because of a special feature called Hoisting.

console.log(greetings); // undefined
var greetings = 'Hello World!';

var exists beyond the block in which it is declared:

Variables declared as var exist beyond the block in which they are defined if not defined inside a function.

if (true) {
var a = 'Hello'
}

console.log(a);

let:

let is now preferred variable declaration and comes as an improvement to var declarations.

let greetings = 'Hello Javascript'

Scope of let:

Variable declared as let is block-scoped.

A block is a chunk of code that resides in {}.
let variables defined inside a block cannot be accessed outside it.

function greetings() {
    let greetings = 'Hello Javascript'
}

console.log(greetings); // Reference error

Improvements over var:

let variables can be updated but not re-declared

let greeting = 'hello'
greeting = 'Hi, Instead'

console.log(greeting); // 'Hi, Instead'

this will result in an error

let greeting = 'Hello';
let greeting = 'Hey'; // this will result in an error

However, if the same variable is defined in different scopes, there will be no error.

Hoisting of let let variables are also hoisted but unlike var, let is not initialized as undefined and cannot be accessed until some value is assigned to let variables.

console.log(greeting); // results in a reference error.
let greeting = 'Hello';

const:

const variables are used when we need to assign a constant value to a variable. const variables must be assigned with a value as soon as they are declared.

const greeting = 'Hello';
console.log(greeting); //Hello

Scope of const:

const variables are block-scoped similar to let.

function greetings() {
    const greetings = 'Hello Javascript'
}

console.log(greetings); // Reference error

Improvements over var:

const variables cannot be updated or re-declared

const greeting = 'hello'
greeting = 'Hi, Instead' // syntax error

Hoisting of const const variables are also hoisted but unlike var, const is not initialized as undefined and cannot be accessed until some value is assigned to const variables.

console.log(greeting); // results in a reference error.
const greeting = 'Hello';

Got any questions or suggestions? let me know
Thanks for reading :)