When learning Node.js, we often encounter the concept of “asynchronous programming.” This is because Node.js is built on the JavaScript language, which is single-threaded. This characteristic makes asynchronous programming crucial for handling high-concurrency I/O operations (such as file reading and network requests). Without understanding asynchronous programming, you might write blocking and inefficient code.

Why Asynchronous Programming?¶

Imagine a Node.js program that needs to read a large file, process its content, and then print the result. With a “synchronous” approach, the code would execute like this:

// Synchronous file reading (simple example; actual large files will be slow)
const fs = require('fs');
const content = fs.readFileSync('bigfile.txt', 'utf8'); // Synchronous blocking, waits for file read completion
console.log('File content result:', processContent(content));

Here, readFileSync is a “synchronous read,” which blocks the entire program until the file is fully read. If the file is large (e.g., several gigabytes), the user will see the program “freeze,” which is clearly unacceptable in real applications.

The benefit of “asynchronous” programming is: When the program performs time-consuming operations (such as waiting for I/O), it does not block the main thread. Instead, it processes other tasks first and then notifies the result via callbacks or Promises after the asynchronous operation completes. This is the core of Node.js’s efficient handling of a large number of concurrent requests.

Callbacks: The Foundation of Asynchronous Programming¶

Initially, Node.js used “callback functions” to handle asynchronous operations. A callback function is a “function called after completion,” and Node.js automatically invokes this function when the asynchronous operation finishes.

Basic Callback Form¶

Taking file reading as an example:

const fs = require('fs');

// Asynchronous file reading
fs.readFile('example.txt', 'utf8', (err, data) => {
  // After asynchronous operation completes, Node.js calls this callback
  if (err) { // Error handling: err will have content if reading fails
    console.error('Reading failed:', err);
    return; // Terminate current callback logic on error
  }
  console.log('File content:', data); // Read successfully, print content
});

console.log('I will execute first!'); // This line outputs immediately, not blocked

Key Details:
- The last parameter of fs.readFile is a callback function, accepting two parameters: err (error object, null on success) and data (result of the asynchronous operation).
- When the asynchronous operation executes, Node.js processes subsequent synchronous code first (e.g., console.log('I will execute first!') above) and does not wait for the asynchronous operation to complete.

Pros and Cons of Callback Functions¶

Pros:¶

• Simple and Intuitive: Directly pass the “processing logic after operation completion” as a parameter, easy to understand.
• No Additional Libraries Needed: Node.js built-in APIs (e.g., fs, setTimeout) all support callback functions, enabling quick onboarding.

Cons:¶

• Callback Hell: When multiple asynchronous operations need to be nested (e.g., “read file A first, then use A’s content to read file B, then use B’s content to read file C”), the code becomes a nested “pyramid,” making it extremely hard to read.

Example of Nested Callbacks (Callback Hell):

// Read file A, then file B, then file C (nested writing)
fs.readFile('A.txt', 'utf8', (err, dataA) => {
  if (err) throw err;
  fs.readFile('B.txt', 'utf8', (err, dataB) => {
    if (err) throw err;
    fs.readFile('C.txt', 'utf8', (err, dataC) => {
      if (err) throw err;
      console.log('Final content:', dataA + dataB + dataC);
    });
  });
});

This nested code is not only hard to read but also makes error handling cumbersome (repeating if (err) in each callback).

Promises: Making Asynchronous Code More Linear¶

To solve “callback hell,” ES6 introduced the Promise object, which is a “promise” that an asynchronous operation will eventually return a result (success or failure). Promises make the execution order of asynchronous code closer to “synchronous code,” significantly improving readability.

Core Concepts of Promises¶

• States: A Promise has three immutable states:
• pending (in progress): Initial state, asynchronous operation is executing.
• fulfilled (success): Asynchronous operation completes, returns a result.

• rejected (failure): Asynchronous operation errors, returns an error message.

• Construction and Usage: Created with new Promise, taking an executor function with two parameters:

• resolve: Called on successful asynchronous operation, passing the result.

• reject: Called on failed asynchronous operation, passing the error.

• Chaining: The .then() method receives a success callback and returns a new Promise, enabling continuous calls (solving nesting issues). The .catch() method uniformly handles errors.

Basic Promise Usage¶

Example 1: Wrapping file reading with Promises¶

const fs = require('fs');

// Wrap fs.readFile into a Promise (Node.js 10+ supports fs.promises)
const readFilePromise = (path) => {
  return new Promise((resolve, reject) => {
    fs.readFile(path, 'utf8', (err, data) => {
      if (err) reject(err); // Call reject on failure
      else resolve(data); // Call resolve on success, pass result
    });
  });
};

// Use Promise to read files
readFilePromise('example.txt')
  .then((data) => {
    console.log('File content:', data); // Result of first asynchronous operation
    return readFilePromise('another.txt'); // Chain call, return new Promise
  })
  .then((data2) => {
    console.log('Second file content:', data2); // Result of second asynchronous operation
  })
  .catch((err) => {
    console.error('Error:', err); // Catch all errors uniformly
  });

Example 2: Simulating Network Requests (using setTimeout to simulate async)¶

// Simulate an asynchronous task (e.g., network request)
const simulateRequest = (success) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => { // Simulate network delay (1 second wait)
      if (success) {
        resolve('Request successful, returned data'); // Resolve on success
      } else {
        reject(new Error('Request failed, network error')); // Reject on failure
      }
    }, 1000);
  });
};

// Use Promise chain
simulateRequest(true) // First request succeeds
  .then((result) => {
    console.log(result); // Output: Request successful, returned data
    return simulateRequest(false); // Second request intentionally fails
  })
  .then((result) => {
    console.log('This will not execute (previous step failed)');
  })
  .catch((err) => {
    console.error('Caught error:', err.message); // Output: Caught error: Request failed, network error
  });

Key Improvement: With .then() chaining, asynchronous code no longer nests. It executes like a “pipeline,” where each step’s result can be directly passed to the next, and errors are uniformly handled with .catch().

Summary: Callbacks vs Promises¶

Core Value of Promises: Make the execution order of asynchronous code closer to “synchronous logic,” avoiding callback nesting chaos and laying the foundation for learning async/await (syntactic sugar for Promises).

Next Learning Direction¶

While Promises solve callback hell, the syntax still has the “then chain” nesting feeling. ES2017 introduced async/await, which further simplifies asynchronous code, allowing you to write asynchronous logic with “synchronous syntax.” If you want to deepen your learning, explore how async/await implements more elegant asynchronous programming based on Promises.

This article aims to help you get started with Node.js asynchronous programming. Remember: callback functions are the foundation, Promises are the progression, and understanding asynchronous thinking is the key to writing efficient Node.js programs!