DEV Community: Asad Mahmood

Middleware in ExpressJS

Asad Mahmood — Tue, 12 Apr 2022 16:01:00 +0000

What are middlewares(hoping that this is the plural of middleware)?

In the simplest of words, a middleware function is that function that gets executed between a request coming in and a response going out. We use middlewares to modularize our code, make it readable, increase reusability and much more.

Types of middleware in express

There are 5 types of middleware:

1. Application-level middleware: These middlewares are bound to the app object and called inside the main application file which means that they are executed after every new request.

2. Router-level middleware: These middlewares are bound to a certain router (instance of express.Router) and are then merged with the main application

3. Error-handling middleware: These middlewares accept 4 arguments, of which the first argument refers to the error that is coming in, also to call these middlewares you have to call the next parameter with a parameter like next which actually is the error that has to be handled in the error handling middleware

4. Built-in middleware.: These are middlewares that are provided with expressjs and don't need any third-party packages to be downloaded

5. Third-party middleware.: These middlewares require some third-party packages to be installed first. For example, express session:

If the current middleware function does not end the request-response cycle(redirecting to another request or sending a response), it must call next() to pass control to the next middleware function.

For more in-depth reading visit express middlewares

Why do we bind event handlers in React???

Asad Mahmood — Sat, 19 Feb 2022 10:30:26 +0000

What is "bind" in Javascript?

Bind is a method inside Function.Prototype which returns a new function whose this keyword's value is set to the value which was passed to the bind method via the parameters.
Example:

In this example, the this keyword of the handleEvent function was changed to the this keyword value of the current context.

But why do we need it in react?

In Class Components in React, we usually pass the event handlers as the callbacks which in turn perform certain actions after the event has taken place. But as we all know, callbacks tend to lose the context which called them(also known as implicitly bound context). To preserve the context we bind the context and then are able to use it inside the event handler.

We don't need to worry about the context when we are using arrow functions (after they were introduced in ES6), because they automatically bind to the scope which called them and hence we don't need to explicitly bind them with the current scope.

Promises in Javascript!!!

Asad Mahmood — Sat, 04 Dec 2021 07:13:33 +0000

P..p..p..promise? Like a bond? Is this a developer blog or an English article? Well, apparently Javascript developers have to deal with promises in their coding life too, and this blog might just be the perfect spot for making you understand what this fuss is all about!

What exactly is a 'Promise'?

A promise, in the simplest language, is a container that is going to store some data in the future time. Going deeper, it is an object, that has multiple states and will return some values depending on if it was successfully resolved, or rejected.

A promise has 3 states, either pending, resolved(fulfilled) or rejected.

Initialising a Promise in Javascript

".then", ".catch" and ".finally" in Promises

Long story short, we can chain methods with promises. The '.then' method is chained with a promise which is then used to handle the promise when it is resolved i.e. the callback function inside the '.then' method is executed and it CAN return another promise(it's not compulsory though). The '.catch' method is chained with the promise and is executed when the promise gets rejected(this block is usually the exception handling block). The callback function which is inside the '.finally' method always gets executed, doesn't matter if the promise was rejected or resolved.

Things I'd love you to know

Promises are asynchronous.
Promises have a different queue(from callbacks) in the background and the Event Loop prioritizes the promise queue over the callback queue, hence it won't execute any callbacks until all the promises inside the promises queue get exhausted.
Promises are generally preferred over callbacks because there is no possibility of falling into the callback hell when working with promises.