DEV Community: Shubham_Baghel

[Boost]

Shubham_Baghel — Tue, 28 Oct 2025 11:15:12 +0000

𝐒𝐨𝐥𝐯𝐢𝐧𝐠 𝐂𝐨𝐥𝐝 𝐒𝐭𝐚𝐫𝐭𝐬 𝐢𝐧 𝐀𝐖𝐒 𝐒𝐞𝐫𝐯𝐞𝐫𝐥𝐞𝐬𝐬 (𝐋𝐚𝐦𝐛𝐝𝐚)

Shubham_Baghel ・ Oct 28

𝐒𝐨𝐥𝐯𝐢𝐧𝐠 𝐂𝐨𝐥𝐝 𝐒𝐭𝐚𝐫𝐭𝐬 𝐢𝐧 𝐀𝐖𝐒 𝐒𝐞𝐫𝐯𝐞𝐫𝐥𝐞𝐬𝐬 (𝐋𝐚𝐦𝐛𝐝𝐚)

Shubham_Baghel — Tue, 28 Oct 2025 09:25:21 +0000

One of the most common performance challenge in serverless app is the Lambda cold start that small delay when AWS spins up a fresh execution environment after inactivity.

Some easy tricks to make Lambda functions start faster in production:

1.𝐔𝐬𝐞 𝐏𝐫𝐨𝐯𝐢𝐬𝐢𝐨𝐧𝐞𝐝 𝐂𝐨𝐧𝐜𝐮𝐫𝐫𝐞𝐧𝐜𝐲

Keeps a set number of Lambda instances always warm.

AWS pre-initialise execution environments for you so no first-call delay.

Configure via Console, CLI, or CDK:
AWS Docs: AWS provisioned concurrency

Tip: Perfect for APIs or real-time workloads (e.g., login or payment endpoints).

2.𝐊𝐞𝐞𝐩 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬 𝐖𝐚𝐫𝐦 𝐰𝐢𝐭𝐡 𝐚 𝐒𝐜𝐡𝐞𝐝𝐮𝐥𝐞𝐫

Trigger your function periodically (every 5–10 mins) to prevent it from going cold.

Use Amazon EventBridge or CloudWatch Schedule for simple pinging.

EventBridge Docs:EventBridge

Tip: Combine this with a lightweight health-check lambda endpoint (like /ping). This is useful in microservices setups for example, after a new deployment, you can quickly test and verify that all functions are warm and responding correctly.

3.𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐞 𝐃𝐞𝐩𝐥𝐨𝐲𝐦𝐞𝐧𝐭 𝐏𝐚𝐜𝐤𝐚𝐠𝐞 𝐒𝐢𝐳𝐞

The bigger your Lambda zip, the longer AWS takes to initialize it.

Bundle only what’s needed (exclude dev dependencies).

Use tools like esbuild, webpack, or AWS SAM build.

Tip: For Node.js avoid installing large libraries like aws-sdk (it’s pre-included) and remove unused packages with library called depcheck.

4.𝐂𝐡𝐨𝐨𝐬𝐞 𝐭𝐡𝐞 𝐑𝐢𝐠𝐡𝐭 𝐑𝐮𝐧𝐭𝐢𝐦𝐞

Cold start time depends heavily on the runtime.

Node.js and Python start up faster than Java or .NET.

AWS SnapStart Doc:AWS SnapStart

Tip: If you need Java, enable AWS Lambda SnapStart
to pre-initialise the function state.

5.𝐁𝐞 𝐂𝐚𝐫𝐞𝐟𝐮𝐥 𝐰𝐢𝐭𝐡 𝐕𝐏𝐂 𝐂𝐨𝐧𝐟𝐢𝐠𝐮𝐫𝐚𝐭𝐢𝐨𝐧

Putting Lambdas inside a VPC adds ENI (Elastic Network Interface) setup time.

Avoid VPC unless you truly need private resources (like RDS).

If required, use VPC endpoints or NAT optimization.
Best Practices for VPC Lambda Networking: VPC configuration

Tip: For DynamoDB, S3, or SNS we can go without a VPC entirely.

6.𝐒𝐩𝐥𝐢𝐭 𝐋𝐚𝐫𝐠𝐞 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬

Monolithic Lambdas = longer cold starts.

Break down your logic into multiple smaller Lambdas (micro-Lambdas).

Tip: This also improves deploy speed and observability.

In one project, our first API call took ~2.4s (cold Lambda in VPC).
After making a few changes like
• Removed VPC dependency
• Enabled provisioned concurrency (2 instances)
• Added an EventBridge warm-up every 10 mins

Cold start dropped to ~150ms consistently.

Best way to deploy Nodejs app

Shubham_Baghel — Thu, 27 Mar 2025 15:56:49 +0000

Deploying a NodeJS Application using Docker on AWS EC2 & Kubernetes (EKS)

Shubham_Baghel ・ Mar 27

#webdev #javascript #aws #docker

Deploying a NodeJS Application using Docker on AWS EC2 & Kubernetes (EKS)

Shubham_Baghel — Thu, 27 Mar 2025 15:44:45 +0000

Deploying a Node.js application using Docker, Kubernetes, and AWS is a multi-step process that requires building the Docker image, configuring Kubernetes for deployment, and setting up AWS services. Below is an process and commands involved

I'll walk through the steps of deploying a simple Node.js application using Docker, Kubernetes, and AWS.

Step 1: Set Up Node.js Application
First, create a simple Node.js application. For this example, we'll use a basic Express server.

Create a server.js file:

// server.js
const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('First Service from Node.js!');
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Step 2: Dockerize the Node.js Application
Create a Dockerfile:

The Dockerfile defines the environment to run your application.

# Step 1: Use the official Node.js image
FROM node:14

# Step 2: Set the working directory inside the container
WORKDIR /usr/src/app

# Step 3: Copy the application code into the container
COPY . .

# Step 4: Install dependencies
RUN npm install

# Step 5: Expose the application port
EXPOSE 3000

# Step 6: Run the application
CMD ["npm", "start"]

Build the Docker image using below command:

docker build -t node-docker-app .

docker run -p 3000:3000 node-docker-app
Now we can check
our application should now be accessible at http://localhost:3000.

Step 3: Push Docker Image to AWS ECR (Elastic Container Registry)
First, create a repository in ECR on AWS Console:

Go to the ECR section of AWS.

Create a new repository, e.g., node-docker-app.

Then, authenticate Docker with AWS ECR:

aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin <aws_account_id>.dkr.ecr.us-west-2.amazonaws.com
Reference Link: link:https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html

Tag the Docker image:
docker tag node-docker-app:latest <aws_account_id>.dkr.ecr.us-west-2.amazonaws.com/node-docker-app:latest

Push the Docker image to ECR:

docker push <aws_account_id>.dkr.ecr.us-west-2.amazonaws.com/node-docker-app:latest

Step 4: Create Kubernetes Deployment Configuration
Create a Kubernetes deployment YAML file to manage your Dockerized app.

Create a deployment.yaml file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-docker-app-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: node-docker-app
  template:
    metadata:
      labels:
        app: node-docker-app
    spec:
      containers:
      - name: node-docker-app
        image: <aws_account_id>.dkr.ecr.us-west-2.amazonaws.com/node-docker-app:latest
        ports:
        - containerPort: 3000

Create a Kubernetes service YAML file:

This exposes your application to the outside world.

Create a service.yaml file:

apiVersion: v1
kind: Service
metadata:
  name: node-docker-app-service
spec:
  selector:
    app: node-docker-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer

Step 5: Set Up Kubernetes on AWS (EKS)
Install kubectl and Install eksctl (for creating an EKS cluster)

brew install kubectl

brew install eksctl

Create an EKS cluster:

eksctl create cluster --name nodejs-cluster --region us-west-2 --nodegroup-name nodegroup --node-type t2.micro --nodes 2

Configure kubectl to use your EKS cluster:

aws eks --region us-west-2 update-kubeconfig --name nodejs-cluster

Step 6: Deploy the Application to Kubernetes
Apply the deployment and service files:

kubectl apply -f deployment.yaml kubectl apply -f service.yaml

Check the status of the deployment:

kubectl get deployments kubectl get pods

Get the LoadBalancer IP:

kubectl get svc node-docker-app-service

The external IP address will be listed under the EXTERNAL-IP column. You can now access the application via the LoadBalancer's IP.

Step 7: Clean Up
When you're done, you can delete the Kubernetes cluster on AWS to avoid any ongoing charges:

`eksctl delete cluster --name nodejs-cluster --region us-west-2

How Lambda will enhance your app scalability

Shubham_Baghel — Sun, 07 May 2023 15:06:22 +0000

Suppose you have an e-commerce site and you need to tune the consumer's behavior for the duration of their visit. You want to recognize how a lot time the purchaser spends on each web page and which pages they go to in what order. This information can help you examine the consumer's hobbies and possibilities and enhance their universal revel in on the website.

One way to reap that is by means of developing a Lambda feature that is caused every time a user visits a web page on your internet site. The function can record the user's consultation facts in a database or file. Here's a pattern code for the Lambda characteristic:

In this case, the Lambda characteristic receives an occasion object that consists of the pageId and sessionId. The pageId is the identifier for the web page that the person is presently visiting, and the sessionId is a unique identifier for the consumer's consultation.

The feature then generates a timestamp and creates an item that includes the sessionId, pageId, and timestamp. It makes use of the AWS SDK to put in writing this object to a DynamoDB table named web page-visit-tracking. Finally, it logs a message indicating that the page visit has been recorded.

This Lambda function can be incorporated together with your internet site's frontend code to ship an occasion item to the Lambda function each time a consumer visits a web page. By doing so, you may music the person's conduct and benefit precious insights into their pursuits and preferences.

Redis with Nodejs

Shubham_Baghel — Mon, 27 Mar 2023 09:38:36 +0000

Introduction

Redis is an in-memory data store that can be used as a database, cache and message broker. The main benefits of using Redis is its speed. Because it's an in-memory database, it can read and write data very quickly with feature like pipeline and transactions, making it a great choice for applications that need to process large volumes of data in real-time. Redis also supports a variety of data structures, including strings, hashes, lists, sets, and sorted sets. This makes it very versatile and useful for a wide range of applications.

To use Redis with node.js,you will need to install "redis" package,We can installed it using below command:

npm install redis

After this lets create Redis client using redis.createclient.This will create a new client that connects to default redis server on localhost:6379.Also we can pass configuration objectin createclient method:


const client = redis.createClient({
    socket: {
        host: '<hostname>',
        port: '<port>'
    },
    password: '<password>'
});

Installation on windows:
Redis installation step for windows

Redis installation step for macOs

Now lets see how we can use client.set() to set a key-value pair in redis,The first argument is key which will be any filed that we need to store and will be consider as KEY and second argument here is actual value and third is callback function that gets executed or called once the execution is complete.


// Set a key-value pair in Redis
client.set('name', 'devtoUser', (error, result) => {
  if (error) {
    console.error(error);
  } else {
    console.log(result); // this will return OK
  }
});

Finally, we use client.get() to get the value of the namekey from Redis.The first argument is the key, and the second argument is a callback function that gets called once the operation is complete. In this example, we log the result to the console if there are no errors.

// Get a value from Redis
client.get('name', (error, result) => {
  if (error) {
    console.error(error);
  } else {
    console.log(result); //this will return devtoUser
  }
});

Redis benefits

Redis also has a number of advanced features that make it a powerful tool for developers. Some of these features include:

Pub/Sub messaging: Redis can be used as a message broker, allowing applications to publish and subscribe to messages. This makes it useful for building real-time applications, such as chat apps or real-time analytics systems.
Lua scripting: Redis has a built-in Lua interpreter, which allows developers to write custom scripts that can be executed on the server. This can be useful for complex data operations that can't be easily performed using built-in Redis commands.
Transactions: Redis supports transactions, allowing developers to group multiple commands together into a single atomic operation. This can help ensure data consistency and prevent race conditions.
Persistence: Redis can be configured to periodically save its data to disk, ensuring that data is not lost if the server crashes or is restarted.

Github Repo:
Redis repo

Additional Radis commands :
Redis commands list

useCallback vs useMemo

Shubham_Baghel — Mon, 06 Mar 2023 14:33:12 +0000

useCallback and useMemo are both React hooks that can be used to optimize the performance of your React application by remembering calculated values in components but there is a slight difference in terms of Return Value, Dependency array. Below is good comparison of both.

Use case: The main use case of useCallback is to remember a function, while the main use case of useMemo is to remember a value.
Return value: useCallback returns a memorized function, while useMemo returns a memorized value.
Dependencies Array:

useCallback takes a dependency array as the second argument, which specifies the values on which the stored function depends. The function will only be recalculated if any value in the dependencies array changes. On the other hand,
useMemo also takes an array of dependencies as the second argument, but it specifies the values on which the remembered value depends. The value will only be recalculated if any value in the dependencies array changes.

Performance Considerations: If you have a computationally expensive function that you need to pass as a prop to a child component, you should use useCallback to remember that function. This will prevent the child component from rendering unnecessarily. If you have a computationally expensive value that you need to use in a component, you should use useMemo to remember that value. This will prevent the value from being unnecessarily recalculated on every new render.

In this example, we use both useMemo and useCallback to remember a value and a function respectively. Expensive value is remembered by useMemo and expensive function is remembered by useCallback. Both hooks depend on the value of the count state and will only recalculate if the count value changes. This can help optimize component performance.

Why to useMemo hook?

Shubham_Baghel — Sun, 05 Mar 2023 12:09:16 +0000

Suppose you have a module that displays a listing of products, each one with its own label and cost. Moreover, you have a separate function that determines the collective price for all the items. This is an illustration of how to employ the useMemo hook to store the result of the total price calculation:


import React, { useMemo } from 'react';

function ItemList({ items }) {
  const totalPrice = useMemo(() => {
    console.log('Calculating total price...');
    return items.reduce((acc, item) => acc + item.price, 0);
  }, [items]);

  return (
    <div>
      <ul>
        {items.map((item) => (
          <li key={item.name}>
            {item.name}: {item.price}
          </li>
        ))}
      </ul>
      <p>Total price: {totalPrice}</p>
    </div>
  );
}

The useMemo hook lets us set up a variable, entitled totalPrice, in this instance. The first piece of the hook is a function that works out the cost of all the items; the second part is an array of dependencies, meaning that React will recalculate the price any time the dependencies alter. In this instance, the only thing that the calculation is reliant on is the items prop.

The useMemo hook memorizes the result of the function, so if the items prop hasn't changed since the last render, React will take the previous result instead of running the function again. This can be helpful for complicated calculations that don't need to be re-run every time the render is executed. For example, if there is a large list of items, figuring out the total cost on every render could be time-consuming; memorizing the result can increase performance.

It is worth noting that useMemo is not a substitute for useEffect. useMemo should be used to store the outcome of a function, while useEffect should be used for completing side effects like obtaining data from an API.

How to Write React Hooks More Effectively

Shubham_Baghel — Sun, 05 Mar 2023 10:30:39 +0000

1.Only call hooks at the top level: Hooks should only be called at the top level of your component or custom hook. Do not call hooks inside loops, conditions, or nested functions

Example:

function MyComponent() {
  const [state, setState] = useState(0);

  function handleClick() {
    setState(state + 1); // This is correct
  }

  return (
    <button onClick={handleClick}>Click me</button>
  );
}

function MyOtherComponent() {
  const [state, setState] = useState(0);

  function handleClick() {
    if (state > 0) {
      setState(state - 1); // This is correct
    }
  }

  return (
    <button onClick={handleClick}>Click me</button>
  );
}

2.Use the state hook for local state: The state hook is the most commonly used hook and should be used for any local state that your component needs.

function MyComponent() {
  const [name, setName] = useState("");

  return (
    <>
      <input value={name} onChange={e => setName(e.target.value)} />
      <p>Hello, {name}</p>
    </>
  );
}

3.Use the effect hook for side effects: The effect hook allows you to synchronize a component with an external system, such as a web API or a browser API.

function MyComponent() {
  const [data, setData] = useState([]);

  useEffect(() => {
    fetch("https://my-api.com/data")
      .then(response => response.json())
      .then(data => setData(data));
  }, []);

  return (
    <ul>
      {data.map(item => (
        <li key={item.id}>{item.name}</li>
      ))}
    </ul>
  );
}

4.Avoid unnecessary re-renders: Hooks like useMemo and useCallback can help you avoid unnecessary re-renders by memoizing values and functions.

function MyComponent({ items }) {
  const sortedItems = useMemo(() => items.sort(), [items]);

  return (
    <ul>
      {sortedItems.map(item => (
        <li key={item.id}>{item.name}</li>
      ))}
    </ul>
  );
}

5.Keep hooks simple: Each hook should only handle one piece of logic, such as setting up a subscription or measuring the size of an element

function useData(url) {
  const [data, setData] = useState([]);

  useEffect(() => {
    fetch(url)
      .then(response => response.json())
      .then(data => setData(data));
  }, [url]);

  return data;
}

function MyComponent() {
  const data = useData("https://my-api.com/data");

  return (
    <ul>
      {data.map(item => (
        <li key={item.id}>{item.name}</li>
      ))}
    </ul>
  );
}

6.Use the context hook to share state: The context hook allows you to share state between components without having to pass props down the component tree.

const MyContext = React.createContext();

function MyProvider({ children }) {
  const [name, setName] = useState("");

  return (
    <MyContext.Provider value={{ name, setName }}>
      {children}
    </MyContext.Provider>
  );
}

function MyComponent() {
  const { name, setName } = useContext(MyContext);

  return (
    <>
      <input value={name} onChange={e => setName(e.target.value)} />
      <p>Hello, {name}</p>
    </>
  );
}

function App() {
  return (
    <MyProvider>
      <MyComponent />
    </MyProvider>
  );
}

In this example, the MyProvider component creates a context and provides the name and setName state to its children via the value prop. The MyComponent component then uses the useContext hook to access the name and setName state from the context.

This way, the name state can be accessed and modified by any component that is a child of the MyProvider component, without having to pass props down the component tree.

7.The handleClick function uses the callback form of the setCount updater, which receives the previous state and returns the new state. This way, the function can update the state based on the previous value, without needing to use a useEffect or useRef to store the previous value.

function MyComponent() {
  const [count, setCount] = useState(0);

  const handleIncrement = useCallback(() => {
    setCount(prevCount => prevCount + 1);
  }, [setCount]);

  const handleDecrement = useCallback(() => {
    setCount(prevCount => prevCount - 1);
  }, [setCount]);

  return (
    <>
      <button onClick={handleIncrement}>Increment</button>
      <button onClick={handleDecrement}>Decrement</button>
      <p>Count: {count}</p>
    </>
  );
}

This approach is useful in situations where the component updates frequently, and you want to prevent unnecessary re-renders caused by changing function references. It also allows to memoize the function, which means it will not recreate the function if the dependencies haven't changed.

8.Use the useEffect hook with a cleanup function: A cleanup function is a function that is executed when a component is unmounted or a hook is re-run

import { useEffect, useState } from 'react';

function MyComponent() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const intervalId = setInterval(() => {
      setCount(count => count + 1);
    }, 1000);
    // Cleanup function
    return () => clearInterval(intervalId);
  }, [setCount]);

  return <p>Count: {count}</p>;
}

In this example, the useEffect hook is used to set up an interval that increments the count state every second. The setInterval function returns an interval ID, which is stored in a variable called intervalId.

The useEffect hook also takes a function as a second argument that is used as a cleanup function. It is executed when the component is unmounted or the hook is re-run. In this case, the cleanup function is used to clear the interval by passing in the intervalId variable to the clearInterval function.

This way, we can ensure that the interval is properly cleared when the component is no longer in use, and avoid memory leaks.

Cleanup functions are a powerful feature of the useEffect hook, they allow you to perform a cleanup operation when a component is unmounted or when a hook is re-run. This makes sure that you don't leave any unnecessary event listeners, timeouts, intervals or other resources that are no longer needed.

9.Always pass the dependencies array to useEffect: This array should include all values that the effect depends on.

import { useEffect, useState } from 'react';

function MyComponent({ userId }) {
  const [userData, setUserData] = useState(null);

  useEffect(() => {
    fetch(`https://jsonplaceholder.typicode.com/users/${userId}`)
      .then(response => response.json())
      .then(data => setUserData(data));
  }, [userId, setUserData]);

  return userData ? (
    <>
      <h2>{userData.name}</h2>
      <p>{userData.email}</p>
    </>
  ) : (
    <p>Loading...</p>
  );
}

In this example, the useEffect hook is used to fetch data from an API based on the userId prop passed to the component. The fetch function is used to make a request to the API, and the then method is used to handle the response and update the userData state.

The second argument passed to the useEffect hook is an array of dependencies, which includes userId and setUserData. These are the values that the effect depends on, so they should be included in the dependencies array.

This way, the effect will only re-run when the userId prop or setUserData state change, and it will not re-run when other props or state values change. This can help to optimize the performance of your component and avoid unnecessary re-renders.

Always passing the dependencies array to the useEffect hook is important because it tells React when the effect should be run again. If you don't specify the dependencies array, React will assume that the effect depends on all the state and props, and will run the effect on every render. This can lead to unexpected behavior and performance issues.

10.Be careful when using hooks in loops: If you want to use a hook in a loop, make sure that each rendered element has its own state

import { useState, useEffect } from "react";

function MyComponent({ items }) {
  return (
    <ul>
      {items.map((item, index) => {
        const [isSelected, setIsSelected] = useState(false);
        return (
          <li key={item.id} onClick={() => setIsSelected(!isSelected)}>
            {item.name} {isSelected ? "Selected" : ""}
          </li>
        );
      })}
    </ul>
  );
}

In this example, My component takes an items prop and maps over it to render a list of items. Each item is rendered as a list item (li) element. Inside the map function, I am using the useState hook to create a isSelected state variable for each item.

By providing a unique key for each item, React can tell which elements are being added, removed, or re-arranged. This way, React can manage the state of each element separately, and you don't have to worry about the hook state being shared across elements.

It is important to be careful when using hooks inside loops, because if you don't provide a unique key for each element, React will not be able to tell which elements are being added, removed or re-arranged, and it will reuse the state of the hook across elements, which can lead to unexpected behavior and bugs.

It's also important to mention that we could use useState inside a callback or inside useEffect instead of directly in the JSX, this way we don't have to worry about different components using the same state.

Promise to Innovate: The Cutting-edge of Asynchronous JavaScript

Shubham_Baghel — Sun, 22 Jan 2023 14:27:14 +0000

Promises in JavaScript are a powerful tool for managing asynchronous code. They allow you to write code that runs asynchronously, while still maintaining a clear and easy-to-understand structure.

A promise is an object that represents the eventual completion (or failure) of an asynchronous operation, and its resulting value. A promise is in one of three states:

A promise in JavaScript goes through three states:

Pending: The initial state, neither fulfilled nor rejected. This is the state when the promise is created and before any action is taken on it.
Fulfilled: This state is reached when the promise is resolved, meaning that the asynchronous operation it represents has completed successfully. The promise's then() callback is called with the resolved value.
Rejected: This state is reached when the promise is rejected, meaning that the asynchronous operation it represents has failed. The promise's catch() callback is called with the rejected value.

Promises are a way to handle asynchronous operations in a more synchronous way. Instead of using callbacks, you can use the .then() and .catch() methods on a promise to handle the results of the asynchronous operation.

You can use the .then() method to handle the successful completion of a promise and the .catch() method to handle any errors.Promise syntax is simple and easy to understand,

1.Promise.all() method
Are you tired of managing asynchronous code one promise at a time? Well, have I got the solution for you: Promise.all()! This handy method lets you party with multiple promises at once, without any of the awkward "waiting for one to finish before moving on to the next" nonsense.

Let's say you're hosting a dinner party, and you want to make sure all your dishes are ready before serving. You could do it the old-fashioned way, by waiting for each dish to finish cooking before starting the next one. But that's so boring and time-consuming! Instead, you could use Promise.all() to cook all the dishes simultaneously, and serve them up as soon as they're all ready.

Here's an example of how you might use Promise.all() in your dinner party scenario:

As you can see, we use Promise.all() to wait for all the dishes to be cooked before serving them. And if one of them doesn't turn out quite right (maybe the steak was overcooked, or the potatoes were undercooked), then the whole party is a bust and we catch the error.

So don't be a party pooper, start using Promise.all() today and turn that asynchronous code into a raging success!

2.Promise.race() method

Let's say you're an online shopper and you've ordered multiple items from different vendors. You want to receive your purchases as soon as possible, without having to wait for all the packages to arrive. Instead, you could use Promise.race() to find out which package will be delivered first.

Here's an example of how you might use Promise.race() in an online shopping scenario:

As you can see, we use Promise.race() to find out which package will be delivered first, without having to wait for the others.

Don't wait for the slowpokes, start using Promise.race() today and receive your purchases in record time!

This example uses a deliver function that simulates the delivery time of a package, and an array of package objects with a name and delivery time. And we are using Promise.race() method to find out which package will be delivered first by resolving the promise when the first package is delivered.

LeetCode Palindrome Number Solution in JavaScript

Shubham_Baghel — Mon, 16 Jan 2023 15:26:52 +0000

LeetCode:
Palindrome Number

Problem statement:
Given an integer x, return true if x is a
palindrome, and false otherwise.

Explanation:
Two pointer approach is best here as we can traverse string from one pointer and decrease it from end of string and check if its same or not

 /**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function(x) {
//convert integer to string
    const convertedString=x.toString();
//create left pointer and right pointer
    let left=0;
    let right=convertedString.length-1;
//iterate till condition meets
    while(left<=right){
//check left string is similar to right or not
        if(convertedString[left]!=convertedString[right]){
           return false;
        }
//increase left pointer and decrease right pointer
         left++;
         right--;
    }
    return true;
};

LeetCode Two Sum problem Solution in JavaScript

Shubham_Baghel — Sun, 15 Jan 2023 06:48:34 +0000

Two Sum
LeetCode Link:[https://leetcode.com/problems/two-sum/]

Problem Statement:
Given an array of integers Nums and an integer target, return indices of the two numbers such that they add up to target.
You may assume that each input would have exactly one solution, and you may not use the same element twice. You can return the answer in any order.

Solution:
1.Brute Force:
In this approach we are iterating array with two loops where we are checking sum of first and next element with target if it matches then we are returning index of element. But in this case Time complexity will be O(N²)

Code:

2.Map based Approach
This solution is more optimize as we are using map and just checking finding out the required element which will be subtracted from current num of array. Here we are checking that element is present in map or not using Map.has() method.(Read more about Map.has() method of Map https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has)
In Nutshell, We can utilize a HashTable to search for the required elements with pair.

Code: