DEV Community: aquibzahidi

Legendary methods of Array in JavaScript | Part 1 : forEach, find, filter and map

aquibzahidi — Tue, 14 Feb 2023 09:12:36 +0000

ForEach, Filter, Find, Map, Reduce, Some and Every are all JavaScript array methods that are used to manipulate arrays and perform various operations on them. In this blog, we will take a look at what each of these methods does, how they can be used and why they are useful for web developers.

In this blog I will discuss forEach, find, filter and map.

.forEach 🔁

The forEach method allows you to iterate over an array and perform a specific operation on each element in the array. It is similar to the for loop, but it is more concise and easier to use.

Here’s the syntax for using the forEach method:

array.forEach(function(currentValue, index, arr) {
  // Your code here
});

The forEach method takes a callback function as its argument. This callback function will be called once for each element in the array. The callback function takes three arguments:

currentValue: the current element being processed in the array
index: the index of the current element
arr: the array that forEach was called upon

Here’s an example of using the forEach method to log the name of each product in the products array:

let products = [
  { name: '🍎', inStock: true },
  { name: '🍌', inStock: false },
  { name: '🥕', inStock: true },
  { name: '🍩', inStock: true },
  { name: '🍆', inStock: false }
];

products.forEach(function(product) {
  console.log(product.name);
});

/*
🍎
🍌
🥕
🍩
🍆
*/

In this example, the forEach method is used to iterate over the products array. For each product in the array, the callback function logs the name of the product.

.find 🔎

The find method is used to find the first element in an array that satisfies a given condition. It takes a callback function as an argument and returns the first element that passes the condition specified in the callback function.

For example, if you have a 🧑🏻‍💼 list of customers and you want to find the first customer who spent more than $100, you can use the find method.

let customers = [
  { name: 'John Doe', orderAmount: 50 },
  { name: 'Jane Doe', orderAmount: 75 },
  { name: 'Jim Smith', orderAmount: 120 },
  { name: 'Jill Smith', orderAmount: 95 },
  { name: 'Jack Johnson', orderAmount: 75 }
];

let highOrderCustomer = customers.find(customer => customer.orderAmount > 100);
console.log(highOrderCustomer);

/*
{ name: 'Jim Smith', orderAmount: 120 }
*/

.filter 🔍

The filter method is used to create a new array from an existing array, but with only elements that pass a certain test. This test is defined in a callback function that you provide as an argument.

Let’s say you have a list of 🎥 movies and you want to create a new list that only includes movies that are rated G. You can use the filter method to achieve this:

let movies = [
  { title: '🐭 The Lion King', rating: 'G' },
  { title: '🦖 Jurassic Park', rating: 'PG-13' },
  { title: '🚀 Space Jam', rating: 'PG' },
  { title: '🏰 Beauty and the Beast', rating: 'G' },
  { title: '🦸‍♂️ Shazam!', rating: 'PG-13' }
];

let kidsMovies = movies.filter(movie => movie.rating === 'G');
console.log(kidsMovies);

/*
[
  { title: '🐭 The Lion King', rating: 'G' },
  { title: '🏰 Beauty and the Beast', rating: 'G' }
]
*/

In this example, the filter method iterates through the movies array and checks each movie's rating. If a movie is rated G, it gets included in the kidsMovies array.

.map 🔄

The map method is used to create a new array from an existing array, by transforming each element in the original array into a new value. The transformation is defined in a callback function that you provide as an argument.

Example 1: if you have a list of 🔢 numbers and you want to create a new list that contains the square of each number, you can use the map method.

let numbers = [1, 2, 3, 4, 5];
let squares = numbers.map(number => number * number);
console.log(squares);

/*
[1, 4, 9, 16, 25]
*/

Example 2: let’s say you have a list of 🍎 apples and you want to create a new list that shows the weight of each apple in grams. You can use the map method to achieve this:

let apples = [
  { type: 'Granny Smith', weight: 150 },
  { type: 'Red Delicious', weight: 120 },
  { type: 'Golden Delicious', weight: 130 },
  { type: 'Fuji', weight: 140 },
  { type: 'Gala', weight: 110 }
];

let appleWeights = apples.map(apple => apple.weight + 'g');
console.log(appleWeights);

/*
[ '150g', '120g', '130g', '140g', '110g' ]
*/

In this example, the map method iterates through the apples array and transforms each apple's weight into a string with the units g. The result is a new array called appleWeights that contains the weights of each apple in grams.

Node.js Cluster Module: Scaling Your Applications

aquibzahidi — Sun, 12 Feb 2023 21:07:32 +0000

It’s essential to optimize your code to handle a large number of requests and ensure that your application performs optimally. One way to improve the performance of your Node.js application is by using the cluster module.

In this blog, we’ll discuss what the Node.js cluster module is, how it works, and how you can use it to improve the performance of your applications.

What is the Node.js Cluster Module?

The cluster module is a built-in module in Node.js that allows you to run multiple worker processes to handle the load of a single application. It enables you to take advantage of all the CPU cores of your system, resulting in better performance and scalability.

How Does the Cluster Module Work?

The cluster module works by forking multiple worker processes from a single master process. Each worker process runs as a separate instance of the application and is responsible for handling requests. The master process is responsible for monitoring the worker processes and forking new ones if necessary.

Imprementing Cluster Module with Express

To use the cluster module with Express, you first need to import the necessary modules, including the cluster and express modules. Then, you can create an Express application and specify an endpoint to handle requests. In the endpoint, you can perform a CPU-intensive task to demonstrate the effectiveness of the cluster module.

Here is an example of how you can use the cluster module with Express:

const cluster = require('cluster');
const express = require('express');
const numCPUs = require('os').cpus().length;
const app = express();

app.get('/', (req, res) => {

  //cpu intensive task
  for(let i = 0; i < 1e8; i++){
    console.log(i)
  }
  res.send(`Hello World! from ${process.pid}`);
});

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} died`);
    cluster.fork()
  });
} else {
  app.listen(3000, () => {
    console.log(`Server Worker ${process.pid} started`);
  });
}

In this example, the cluster.isMaster condition checks if the current process is the master process. If it is, the master process forks multiple worker processes using the cluster.fork() method. If the current process is a worker process, the Express application listens to requests on port 3000.

The master process also listens for the exit event, which is emitted when a worker process dies. In this example, if a worker process dies, the master process forks a new one to replace it.

Benefits of Using the Cluster Module

There are several benefits to using the Node.js cluster module, including:

Improved performance: By forking multiple worker processes, you can take advantage of all the CPU cores of your system, resulting in improved performance.
Better scalability: By forking new worker processes as necessary, you can handle a large number of requests without sacrificing performance.
Improved reliability: If a worker process crashes, the master process can automatically fork a new one, ensuring that your application remains available and reliable.
Easy to implement: The cluster module is a built-in module in Node.js, so you don’t need to install any additional packages. Additionally, it’s straightforward to implement and can be added to your existing applications with minimal changes.

In Conclusion, The Node.js cluster module is an excellent tool for improving the performance and scalability of your applications. By forking multiple worker processes, you can take advantage of all the CPU cores of your system and handle a large number of requests efficiently. Additionally, the cluster module provides improved reliability by forking new worker processes if a worker process crashes.

Optimizing Node.js Performance with Redis Caching

aquibzahidi — Thu, 26 Jan 2023 05:00:59 +0000

Caching is necessary in Node.js because it can improve the performance and scalability of a web application. Caching allows frequently accessed data to be stored in a fast, in-memory store, so that it can be quickly retrieved without having to be recalculated or fetched from a slower, persistent storage layer. This can significantly reduce the load on the server, improve response times for users, and make the application more scalable by reducing the need for expensive database queries. Additionally, caching can also help to reduce the amount of data that needs to be transferred over the network, which can help to improve the overall user experience.
One popular tool for implementing caching in Node.js is Redis, an in-memory data store. In this article, we’ll walk through the steps for implementing Redis caching in a Node.js application.

Step 1: Install Redis server -
Windows:

Download the Redis Windows installer from the official website (https://github.com/microsoftarchive/redis/releases)
Run the installer to install Redis on your system.
Open the Command Prompt and Run the command redis-cli to start the Redis server.

macOS:

Install Redis using Homebrew by running the command brew install redis.
Start the Redis server by running the command redis-server.

To check if the Redis server is running correctly, type PING in the terminal. The server should respond with PONG, indicating that the server is up and running.

Step 2: Install Redis Client for node.js

To use Redis in a Node.js application, we’ll need to install the Redis client for Node.js.

npm i redis

Step 3: Create a Redis client instance

Next, we’ll create a Redis client instance in our Node.js application.

const redis = require("redis");
const client = redis.createClient({
  host: "127.0.0.1",
  port: 6379,
});

When creating a Redis client, it’s important to specify the host and port on which the server is running, so that the client can easily connect to the server.

Step 4: Create middleware to handle caching

We’ll create a middleware function to handle caching in our Node.js application. This function will check if the requested data is already stored in the cache, and if so, it will return the cached data to the user. If the data is not in the cache, the function will call the next middleware in the chain and store the response in the cache for future requests.

function cache(req, res, next) {
  const key = "__express__" + req.originalUrl || req.url;

  client.get(key).then(reply => {

    if (reply) {
      res.send(JSON.parse(reply));
    } else {
      res.sendResponse = res.send;
      res.send = (body) => {
        //expire in 1 min
        client.set(key, JSON.stringify(body), {'EX':60});
        res.sendResponse(body);
      };
      next();
    }
  }).catch(err=>{
    console.log(err);
    res.status(500).send(err)
  });
}

In the cache function, we create a key based on the URL, so that we can retrieve and store data according to the URL and send the response. The function also sets a time-to-live (TTL) of one minute for the cached data, after which it will expire and the next request will have to retrieve the data again.

Step 5: Use the caching

middleware in your application
To use the caching middleware in our application, we’ll need to add it to the Express middleware stack using the app.use() function.

app.use(cache);

Step 6: Use the cache

In this example, we’ll use the caching middleware for a simple endpoint that generates a large amount of data.

app.get("/data", (req, res) => {
  let data = 0;
  for (let i = 1; i < 100000000; i++) {
    data += 1;
  }
  res.json(data);
});

Step 7: Connecting redis client with server

app.listen(3000, () => {
  console.log("Server listening on port 3000");
  client.connect().then(()=> {
    console.log('redis is connected')
  })
});

Upon initiating the Express server, we established a connection between the Redis client and its corresponding server, ensuring seamless data storage and retrieval.

Note:
For a detailed, line-by-line implementation, be sure to check out our repository file on Caching in node.js
For accessing more advance Node.Js topics, visit out repository on Advance Node.js.

By implementing Redis caching, you can significantly improve the performance and scalability of your Node.js application. Caching is a powerful tool for reducing server load and improving response times, and Redis is a popular choice for implementing caching in Node.js. By following the steps outlined in this article, you can easily add Redis caching to your Node.js application and start reaping the benefits of improved performance and scalability.