DEV Community: biplavmz

What is Illegal Shadowing

biplavmz — Tue, 30 Apr 2024 19:36:06 +0000

It is a Situation where a variable in a inner Scope **(such as Block,Function) **unintentionally Hide a variable for the same name in an outerScope

Example 1 :->
`var x = 10;

function m1(){
console.log(x)
var x = 100;
console.log(x);
}

m1();`

What is Variable Shadowing in Javascript

biplavmz — Tue, 30 Apr 2024 18:24:33 +0000

when variable Shadowing occur in which condition

Variable Shadowing occurs when a variable Declare with a local Scope (such as in function or block level Scope)
has the same name as a variable in the outerScope.
as the result inner variable shadow the outer variable
it will work for all (var,let,const)

`var x = 10;;

function m1(){
var x = 100; // inner variable will shadow the outer variable
console.log(x);
}

m1(); // it will print 100;
console.log(x); // it will print 10`

Recursion

biplavmz — Mon, 06 Mar 2023 15:43:20 +0000

Recursion

Recursion is the technique of making a function call itself.

This technique provides a way to break complicated problems down into simple problems which are easier to solve.

It is a feature used in creating a function that keeps calling itself but with a smaller input every consecutive time until the code's desired result from the start is achieved.

Adding two numbers together is easy to do,
but adding a range of numbers is more complicated.

In the following example, recursion is used to add a range of numbers together by breaking it down into the simple task of adding two numbers:

let count = 1;

function m1(number){
    if(count > number){
        return;
    }
    console.log("Hello World :- "+count);
    count++;
     m1(number);
}

m1(10);

What will the code below output to the console and why?

biplavmz — Mon, 06 Mar 2023 08:28:58 +0000

`(function (){ var a = b = 5; })();

console.log("a define ? :- "+ (typeof a !== 'undefined')) console.log("b define ? :- "+ (typeof b !== 'undefined'))
`
Since both a and b are defined within the enclosing scope of the function

most JavaScript developers would expect typeof a and typeof b to both be undefined in the above example.

However, that is not the case. The issue here is that most developers incorrectly understand the statement var a = b = 3; to be shorthand for:

`var b = 3;

var a = b;`

But in fact, var a = b = 3; is actually shorthand for:

`b = 3;

var a = b;`

As a result (if you are not using strict mode), the output of the code snippet would be:
`
a defined? false

b defined? true`

But how can b be defined outside of the scope of the enclosing function? Well, since the statement var a = b = 3;

is shorthand for the statements b = 3; and var a = b;, b ends up being a global variable (since it is not preceded by the var keyword) and is therefore still in scope even outside of the enclosing function.

Note that, in strict mode (i.e., with use strict), the statement var a = b = 3; will generate a runtime error of ReferenceError: b is not defined, thereby avoiding any headfakes/bugs that might othewise result. (Yet another prime example of why you should use use strict as a matter of course in your code!)

How to Avoid JavaScript Type Conversions (Type Coercion)

biplavmz — Sat, 04 Mar 2023 14:28:06 +0000

JavaScript performs implicit conversions between data types. Let’s find out how to avoid it.

Have you ever experienced a scenario where certain value comparisons in JavaScript do not result in what you expected?

`if([]){
console.log("working");
}

if(0){
console.log("working for 0");
}

if([]==0){
console.log(true);
}
`

Even though []==0 results in true , the if condition has not executed according to that result. Ever wondered why that is?

*What are JavaScript Type Conversions?
*
it is simply the automatic conversion of values from one data type to another.
This occurs because JavaScript is a weakly typed language.

Use strict comparison (===) when comparing values we can Avoid JavaScript Type Conversions

Hoisting

biplavmz — Thu, 02 Mar 2023 17:37:38 +0000

In JavaScript, a variable can be declared after it has been used.

In other words; a variable can be used before it has been declared.

`var x = 7;

function m1(){
console.log("hello World");
}

m1();
console.log(x);

//output

hello World
7`

and IF we declare before assign than

`m1();
console.log(x);

var x = 7;

function m1(){
console.log("hello World");
}

// output

hello World
undefined`

`m1();
m2();

function m1(){
console.log("hello data");
}

const m2 = ()=>{
console.log("h2");
}

// output

hello data

m2();
^

ReferenceError: Cannot access 'm2' before initialization`

How To Read GitHub Code Like Pro

biplavmz — Sat, 18 Feb 2023 08:48:14 +0000

Check video

what is callback function in javascript

biplavmz — Tue, 14 Feb 2023 17:33:26 +0000

a callback function is a function
that is passed as an argument
to another function and is intended to be called later in the execution of that function.

The purpose of a callback function is to

allow for asynchronous programming.
where a function can be executed while other code is running,
and then execute the callback function when it's finished.

Callback functions are commonly used in event handling,
AJAX requests, and other asynchronous operations.

Q. Interview Question related to Callback functions

Q1.Explain what a callback function is and provide a simple example

A callback function is a function that is passed to another function as an argument and is executed after some operation has been completed.

Below is an example of a simple callback function that logs to the console after some operations have been completed.

`function modifyArray(arr, callback) {
// do something to arr here
arr.push(100);
// then execute the callback function that was passed
callback();
}

var arr = [1, 2, 3, 4, 5];

modifyArray(arr, function() {
console.log("array has been modified", arr);
});`

Google JavaScript Technical Interview (Callbacks, Promises, Await/Async)

Callbacks
What is a Callback in JavaScript
Callbacks in real Life
Callbacks vs. ES6 Promises & Await / Async
Why Promises
What are Promises
How Promises resolves Callback Hell

Why do we even need Callback in JavaScript?

(https://medium.com/developers-tomorrow/google-javascript-technical-interview-7a20accd6ddf)

Higher-Order Components

biplavmz — Thu, 09 Feb 2023 16:28:20 +0000

A higher-order component (HOC) is an advanced technique in React for reusing component logic. HOCs are not part of the React API, per se. They are a pattern that emerges from React's compositional nature.

Concretely, a higher-order component is a function that takes a component and returns a new component.

const EnhancedComponent = higherOrderComponent(WrappedComponent);

Whereas a component transforms props into UI, a higher-order component transforms a component into another component.

*what is HigherOrder Function
*
higher order function is a function that it accepts a function as an arrugment
HOCs basically incorporate the don't-repeat-yourself (DRY) principle of programming, which you've most likely come across at some point in your career as a software developer.

static site generator

biplavmz — Tue, 07 Feb 2023 18:59:52 +0000

A static site generator is a tool that generates a full static HTML website based on raw data and a set of templates.

Lodash

biplavmz — Tue, 07 Feb 2023 18:23:56 +0000

What is Lodash and why to use?

Lodash is a JavaScript library.
It helps in working with arrays,strings,objects,numbers,etc.
It provides us with various inbuilt functions.
It uses a functional programming approach which that coding in JavaScript easier to understand because instead of writing repetitive functions, tasks can be accomplished with a single line of code.
It also makes it easier to work with objects in JavaScript if they require a lot of manipulation to be done upon them.

Why Lodash?

It provides various inbuilt functions for collections, arrays, to manipulate objects, and other utility methods that we can use directly instead of writing them from scratch.

It makes it easier to iterate over the arrays, strings as well as objects. Its modular methods enable the creation of composite functions easier.