Asynchronous programming #

Asynchronous programming is fundamental in Node.js to handle concurrent operations efficiently and avoid blocking the event loop. Here’s a comprehensive overview of the basics of asynchronous programming in Node.js:

Callback Functions: #

Callbacks are a traditional way of handling asynchronous operations in Node.js. Functions that perform I/O operations take a callback as an argument, which is executed when the operation is complete.

Copy code
const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log(data);
});

Event Emitters: #

Node.js utilizes the Event Emmitter pattern for handling events asynchronously. Core modules like fs or custom objects can emit events.

Copy code
const EventEmitter = require('events');
const myEmitter = new EventEmitter();

myEmitter.on('customEvent', () => {
    console.log('Event triggered!');
});

myEmitter.emit('customEvent');

Promises: #

Promises provide a cleaner syntax for handling asynchronous code, avoiding callback hell. The Promise object represents the eventual completion or failure of an asynchronous operation.

Copy code
const readFilePromise = (file) => {
    return new Promise((resolve, reject) => {
        fs.readFile(file, 'utf8', (err, data) => {
            if (err) reject(err);
            resolve(data);
        });
    });
};

readFilePromise('file.txt')
    .then(data => console.log(data))
    .catch(err => console.error(err));

Async/Await: #

Introduced in ECMAScript 2017, async and await further simplify asynchronous code. Functions marked with async return promises, and await is used to wait for a promise to resolve before proceeding.

Copy code
const readAndLog = async () => {
    try {
        const data = await readFilePromise('file.txt');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
};

readAndLog();

Concurrency with Promise.all: #

Promise.all allows running multiple asynchronous operations concurrently and awaiting their completion.

Copy code
const fetchData = async () => {
    const [result1, result2] = await Promise.all([
        fetchDataFromAPI('endpoint1'),
        fetchDataFromAPI('endpoint2')
    ]);

    console.log(result1, result2);
};

Error Handling: #

Proper error handling is crucial in asynchronous code to prevent unhandled exceptions. Use try-catch blocks, catch on promises, or .catch with async/await.

Copy code
const fetchData = async () => {
    try {
        const result = await fetchDataFromAPI('endpoint');
        console.log(result);
    } catch (error) {
        console.error(error);
    }
};

Callback Patterns: #

Common callback patterns include error-first callbacks, where the first parameter of the callback is reserved for an error object.

Copy code
const getData = (callback) => {
    // Simulating an asynchronous operation
    setTimeout(() => {
        const error = null;
        const data = { key: 'value' };
        callback(error, data);
    }, 1000);
};

getData((err, result) => {
    if (err) {
        console.error(err);
    } else {
        console.log(result);
    }
});

In summary, mastering asynchronous programming is crucial for efficient Node.js development. Callbacks, Promises, and Async/Await are powerful tools, each offering its own advantages. The choice depends on the use case and the level of abstraction desired for handling asynchronous operations in a Node.js application.