Reading Data in Batches with JavaScript

In previous lessons, you learned how to handle datasets stored in compressed formats and manage large datasets efficiently using JavaScript. Building on that foundation, today's lesson will teach you how to read and process data in batches from multiple CSV files. This is important because working with data in smaller chunks, or batches, can make your code more efficient and faster when dealing with large datasets.

Our focus in this lesson will be on a practical scenario where a dataset containing car information is spread across multiple files. You will learn to read, process, and analyze this data to extract meaningful insights, such as determining the car with the lowest price.

In this lesson, we'll work with a set of CSV files containing car data. Here's what a typical record might look like:

• Model: Ford Mustang
• Transmission: Automatic
• Year: 2020
• Price: 25000.00
• Distance Traveled (km): 50000
• Color: Red

These files are divided into multiple parts to allow batch processing, and understanding their structure is crucial as you learn to read and process them efficiently.

Let's delve into reading these CSV files in batches using the fs module and csv-parser library in JavaScript. We'll build our solution step by step.

First, we need to specify the filenames for our CSV files and prepare a data structure to hold the combined data.

const fs = require('fs');
const csv = require('csv-parser');

// Filenames to read
const filenames = ['data_part1.csv', 'data_part2.csv', 'data_part3.csv'];

// List to store all car data
let carData = [];

Here, we initialize a list of filenames and create an empty array carData to store all the car data read from the files.

Next, we'll loop through each filename, read the data, and append it to our carData array.

let filesRead = 0;
filenames.forEach((filename) => {
    fs.createReadStream(filename)
        .pipe(csv())
        .on('data', (row) => {
            // Convert price from string to float for comparison
            row.price = parseFloat(row.price);
            carData.push(row);
        })
        .on('end', () => {
            filesRead += 1;
            if (filesRead === filenames.length) {
                // Process the combined data here
            }
        })
        .on('error', (error) => {
            console.error('Error reading file:', error);
        });
});

In this snippet:

• We employ fs.createReadStream() to open each CSV file.
• The csv-parser library reads each line, converting it from CSV directly to a JavaScript object.
• We parse row.price from a string to a float for numerical comparison and store the entire row in carData.
• The end event checks if all files have been processed.

After reading all the data into carData, the next step is identifying the car with the lowest price.

const lowestCostCar = carData.reduce((minCar, car) => {
    return car.price < minCar.price ? car : minCar;
});

console.log(`Model: ${lowestCostCar.model}`);
console.log(`Price: $${lowestCostCar.price.toFixed(2)}`);

Here:

• We use JavaScript’s reduce() function to find the car with the lowest price in carData.
• This method iterates through each object in the array, comparing the price field.
• We then print the model and price of the car with the lowest price, providing a clear output.

Instead of loading all data into memory, a streaming approach can process each record as it's read. This is beneficial for systems with limited memory or when working with extremely large datasets.

let lowestCostCar = null;
let lowestPrice = Infinity;

filenames.forEach((filename) => {
    fs.createReadStream(filename)
        .pipe(csv())
        .on('data', (row) => {
            const price = parseFloat(row.price);
            if (price < lowestPrice) {
                lowestPrice = price;
                lowestCostCar = row;
            }
        })
        .on('end', () => {
            filesProcessed += 1;
            if (filesProcessed === filenames.length && lowestCostCar) {
                console.log(`Model: ${lowestCostCar.model}`);
                console.log(`Price: $${lowestPrice.toFixed(2)}`);
            }
        })
        .on('error', (error) => {
            console.error('Error reading file:', error);
        });
});

In this implementation:

• We maintain two variables: lowestCostCar to store the data of the car with the lowest price and lowestPrice, initialized to infinity.
• We parse and compare the price field for each record in the file. If a record's price is lower, we update lowestPrice and store the record in lowestCostCar.
• This approach reduces memory usage since we do not retain unnecessary data.

In this lesson, you learned how to:

• Read data in batches from multiple CSV files using JavaScript’s fs module and csv-parser.
• Process that data efficiently and convert data types when necessary.
• Identify specific insights, such as the car with the lowest price, utilizing JavaScript methods like reduce().

Now, you're ready to apply these skills with practice exercises designed to reinforce your understanding. These exercises will challenge you to read and analyze data from similar datasets efficiently. Continuous practice is key to mastering these data handling techniques.