DEV Community: arpitashrivastav

Currying in JavaScript

arpitashrivastav — Sat, 31 Jan 2026 14:45:37 +0000

Currying is advanced technique of working with functions.

Currying is advanced technique of working with functions.Currying is advanced technique of working with functions.Currying is advanced technique of working with functions.Currying is advanced technique of working with functions.Currying is advanced technique of working with functions.

Call, Apply and Bind Method in JavaScript.

arpitashrivastav — Mon, 26 Jun 2023 17:44:37 +0000

Look at the code below to see how we defined a variable and specified a function within it to get the intended result.

Call Method

Let's declare another variable, and if you think declaring that function again here will be acceptable, think again. This is not a good practise. So this is where call method comes in picture.

Apply Method

The apply method is extremely similar to the call method, with the main difference being how we pass arguments, with the first argument being a reference to this and the second argument being a list of the arguments that we pass in the function. Instead of sending these arguments individually using a coma in call method, we pass them in an array list to the apply method.

Bind Method

The bind method is quite similar to the call method, with the exception that the bind method links this method (function name) with the object and then returns a copy of the method (that function). There is a catch over there that does not directly call the function but instead returns a duplicate of that function that we can call later.

Thank you for reading.

What is Hoisting in JavaScript?

arpitashrivastav — Mon, 26 Jun 2023 15:32:47 +0000

Introduction

Did you note that in the preceding example, we declared a variable after the console.log of x and invoked the function before declaring it? But wasn't this a surprise given that we received undefined for a variable and the output of function but not an error?

So if you didn't know this then let's learn about hoisting
in JavaScript.

A phenomenon in JavaScript by which we can access variables and functions before declaring it, is known as hoisting.

How this happens?

This is because the variables are already assigned with a spatial value of undefined in the memory space during the memory creation phase.
In the case of functions, the entire code is kept in memory space.
Thus because they are stored during the 1st phase which is the memory creation phase, is the reason we don't get any error when we run the code.

Are Arrow functions hoisted?

As we can see that when we attempted to invoke the getName function before declaring it in the arrow function, we received a TypeError, indicating that getName is not a function.

This occurred because when we attempted to execute this arrow function, it issued an error since it operates similarly to a variable. So, just as variables are allocated as undefined in a memory space, arrow functions are also allocated as undefined in the memory space during the memory creation phase.

Are let and const hoisted?

Yes, let and const are hoisted, but not in the same way that var declarations are. So, if we try to access let and const before declarations, we receive a ReferrenceError that states they are not defined.

So how will we know they've been hoisted?

So it is because we have var x in the global scope whereas a and b are in a different scope, which is script.

So in the memory creation phase even a and b are assigned an undefined spatial value in the memory space, but it is just saved in another memory space.

So they've been hoisted, but why are we still getting a ReferrenceError?

This is because let and const are hoisted but they are in the Temporal Dead Zone for the time being.

Temporal Dead Zone

The time period between the variables being hoisted to until they are assigned a value is known as the temporal dead zone.

As we can see below, we initialised the variable at line 3, hence anything above line 3 was the temporal dead zone for a.

So, based on the information provided above, we can deduce that hoisting occurs in conventional function declarations and variable declarations of var let and const, however there is a variation in behaviour with let, const, and var.

Thank you for taking the time to read this.
I hope you found this useful.