Nodejs中的Javascript异步编程模式

Nodejs中的JavaScript异步编程模式

PubSub模式

Node.js 的 API 架构师非常喜欢发布/订阅（PubSub）模式，因此引入了一个名为 EventEmitter 的实体，几乎所有的 I/O 对象都继承自 EventEmitter。事件与事件处理器是 JavaScript 中最基本的设计模式之一。

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
  console.log('an event occurred!');
});

myEmitter.emit('event'); // 输出: an event occurred!

Promise

尽管 EventEmitter 模式非常强大，但它并不适合所有场景，特别是处理一次性事件的任务。在这种情况下，我们可以使用 Promise 来处理。

const getMyData = () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve('Data fetched successfully');
    }, 2000);
  });
};

getMyData()
  .then(data => {
    console.log(data); // 输出: Data fetched successfully
  })
  .catch(error => {
    console.error(error);
  });

Async.js 工作流控制

对于一组 I/O 操作（并行或串行），我们可以使用 async.js 库来进行工作流控制。

const async = require('async');

async.parallel([
  function(callback) {
    setTimeout(() => {
      console.log('Task 1 completed');
      callback(null, 'Result 1');
    }, 1000);
  },
  function(callback) {
    setTimeout(() => {
      console.log('Task 2 completed');
      callback(null, 'Result 2');
    }, 2000);
  }
], function(err, results) {
  console.log(results); // 输出: [ 'Result 1', 'Result 2' ]
});

多线程技术

虽然事件驱动模型很强大，但在多核 CPU 环境下，我们可能需要更强大的多线程技术。Node.js 提供了 cluster 模块来实现这一需求。

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const cpuCount = os.cpus().length;

  for (let i = 0; i < cpuCount; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
  });
} else {
  // 子进程的工作逻辑
}

异步脚本加载

为了优化页面加载性能，我们可以使用 yepnope 或 Require.js 进行异步脚本加载。

yepnope({
  load: 'js.js',
  callback: function() {
    console.log('Script loaded and executed');
  }
});

require(['moment'], function(moment) {
  console.log(moment().format('dddd')); // 输出当前日期
});

结论

以上只是异步编程模式的一部分内容。Node.js 提供了多种工具来处理异步编程，掌握这些工具将帮助你编写高效、可维护的代码。希望本文能为你提供一些有用的参考。

Nodejs中的JavaScript异步编程模式

1. PubSub模式（订阅分发）

Node.js中的EventEmitter对象几乎被所有I/O对象继承，它提供了事件触发与监听机制。通过这种方式，你可以订阅某个事件并在事件触发时执行相应的处理器。

示例代码：

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

myEmitter.on('event', () => {
  console.log('An event occurred!');
});

myEmitter.emit('event'); // 输出: An event occurred!

2. Promise

Promise是一种处理异步操作的方式，它可以更优雅地处理成功或失败的结果。

示例代码：

const fetch = require('node-fetch');

const promise = fetch('https://jsonplaceholder.typicode.com/todos/1');

promise.then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));

3. Async.js 工作流控制

Async.js 是一个流行的库，用于处理复杂的异步操作，如并行或顺序执行异步函数。

示例代码：

const async = require('async');

async.parallel([
  function(callback) {
    setTimeout(() => callback(null, 'one'), 200);
  },
  function(callback) {
    setTimeout(() => callback(null, 'two'), 100);
  }
], function(err, results) {
  console.log(results); // 输出: [ 'one', 'two' ]
});

4. 多线程技术

在Node.js中，cluster模块可以用来创建多个工作进程，每个进程都在独立的CPU核心上运行。

示例代码：

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const coreCount = os.cpus().length;
  for (let i = 0; i < coreCount; i++) {
    cluster.fork();
  }
} else {
  console.log(`Worker ${process.pid} started`);
}

5. 异步脚本加载

使用yepnope或Require.js可以实现更灵活的脚本加载策略。

示例代码：

const yepnope = require('yepnope');

yepnope({
  load: 'script.js',
  complete: function() {
    console.log('Script loaded and executed.');
  }
});

总结

以上介绍了几种在Node.js中常用的异步编程模式。通过理解和使用这些模式，可以更有效地管理复杂的异步逻辑，提升应用性能和可维护性。