​ 注:本附录主要取自作者网站blog.scottfrees.com上的一系列博客文章，其中涵盖了将现有的C/C++程序*集成到一个Node.js 的各种方法。这个系列是独立于本书的，因此，您可能会发现其中的一些内容是多余的，但是它展示了一个真实的例子，它集成了legacy（老版本）的c++代码，而不是书中狭义的例子。该部分还有一个不同的github存储库，可以从本书的其他例子中下载代码。强烈建议您获取代码，因为其中有很多没有在文本中显示!

​ 这本书的重点是 Node.js C++ addons作为集成Node.js和c++的方法。在许多情况下，addons确实是进行这种集成的最佳选择，但是还有其他选择——如果不讨论这些选项，这本书就不完整了。在这样做之前，让我们后退一步，在第1章中重新询问这个问题:为什么要集成 Node.js 和 C++?为了加强讨论，让我们从现有的c++ /C程序的角度来看这个问题，您希望能够访问web。

​ 我就不能写一个c++网站吗?

​ 嗯…是的,你可以!在很长一段时间内，人们一直在用c++使用CGI编写web应用程序的部分内容。CGI并不是当今网络上最受欢迎的东西，它缺乏大量的生产力增强，使得web开发今天变得如此的伟大。更重要的是，它引入了一些重要的性能和可伸缩性问题。另一方面，c++在过去的几年里在表达方面取得了长足的进步，c++ 14标准使一些非常酷的项目专注于在纯c++中编写现代的MVC-styled的web应用程序。如果这是你的事情，那就去看看Silicon。

​ 大多数web开发人员不是c++程序员，坦率地说，除非您的web层的超高性能是至关重要的，否则您最好使用提供更高级别抽象的语言。网络上后台的通常运行的是Ruby, Go, Node.js, Python, PHP等等。

​ Node.js有很多优点。首先，它以几种不同的方式与c++很好地集成在一起——当然，我们在本书中看到了这一点!一般来说, Node.js也有很多好处，它与你最初使用c++的原因是一样的——它是高度可移植性的，它促进了规模的性能，并且有一个繁荣的ecosystem。

​ 啊…每个开发人员的第一个本能——“让我们重写这个用语言X编写的旧代码，因为语言Y要比|好得多，|更快|更容易!”首先，如果您有一些简单、小且不需要高性能的 legacy(老版本)c++代码，这可能是最好的答案。然而，如果你属于那个类别，你可能没有读到这篇文章——你很可能已经重写了c++代码。

首先：不重写代码有一些实际的原因。首先，您可能没有代码!信不信由你，如果你为一家使用传统工具来支持业务的公司工作，那么这些工具的源代码常常会丢失。这是当您的遗留代码使用第三方依赖时，不能重写或修改的时候。

**第二：**C/C++可能是复杂的，如果它是旧的，可能很难破译。您是一个web开发人员，也是c++的专家吗?你能完全重现这个程序的精确输入/输出吗?如果这是一个关键的业务工具，你就会给你的盘子带来很多风险。

第三：不重写c++的原因是它可能真的想要使用c++ !当Node.js 的性能很好，根本不是 C/C++。如果您的应用程序有极端的性能标准，那么您将不会超过c++。

C++ 集成到 Node.js 的方案

有三种通用的方法将c++代码与Node.js应用程序集成在一起。——尽管每个类别中有很多不同的变体。

1. Automation ：在子进程中，将c++作为一个独立的应用程序。
2. Shared library ：在共享库(dll)中打包您的c++例程，并从Node.js 直接调用这些事例。

3. Node.js Addon ：编译你的c++代码作为一个本地Node.js 模块/addon(我们现在都知道了，对吧?)

   每个选项都有各自的优点和缺点，它们主要在您需要修改c++的程度上有所不同，在调用c++时，您愿意接受的性能打击，以及您在处理 Node.js和V8 API 时的熟练度/安全性。
   

选择依据

​ 最明显的问题是，您是否可以访问c++源代码，或者仅仅是二进制文件?如果没有源代码，您需要希望c++程序可以是命令行程序，也可以是dll/lib共享库。如果你看的是一个只有图形用户界面的程序，那么你就处在痛苦的世界里。您可能需要重写您的应用程序，以便使其在web上工作。

Automation

​ 如果您的c++运行作为一个独立的命令行，您不需要源代码来利用选项1 -automation 选项。您可以使用Node的子进程API 运行您的c++程序。这个选项适用于将任何东西带到web上——如果你只是运行它的话，你的命令行程序写在什么语言上并没有什么区别。如果您正在阅读这篇文章，希望获得C代码、Fortran代码或其他一些语言，那么这个选项值得一读。

​ 自动化选项不仅仅针对那些没有c++代码的人。如果您有c++代码，或者可以很容易地转换成命令行程序，那么这个选项是合理的，如果您可以使用性能，并且您并不想陷入语言集成的麻烦中。

Shared Library / DLL

​ 如果您处理的是c++ dll/lib，或者您有c++源代码，并且可以进行适当的修改，以创建动态库，那么 shared library 方法可能对您很有效。在本章中，我们将详细介绍如何使用外部函数接口模块进行此操作。这个选项可以让您更精确地控制如何将c++集成到节点中，因为对c++例程的调用通常可以直接写到Node.js代码中。虽然这种方法可以使您更接近完整的集成，但是您仍然需要处理类型转换和在调用c++时阻塞。如果您想要更好的集成，这是一个很好的选择，而无需花费大量时间来处理V8。

Node.js Addon

​ 如果您有c++源代码，那么第三个选项是创建一个本机 Node.js模块调用你的c++。虽然这是一个更具挑战性的方法，但是您获得了大量的灵活性和性能。您还可以选择异步调用您的c++，这样您就不会阻塞web应用程序的事件循环，而c++正在处理数字。当我们在本节中介绍这部分内容时，它将主要作为对书中主要章节中已经介绍的材料的回顾。

例子 - 质数分解

​ 在本节中，我将向您展示如何实现上述每个选项的示例。我想在每个例子中都使用相同的基本例子。素数对于很多东西(比如密码学)来说是极其重要的，而它们的生成往往是非常耗时的。在线快速搜索将会引导你转向C和c++的实现，而真正高效的实现是复杂的。看看他们的来源，你会马上意识到你可能不想重写他们——除非你只是在寻找一个挑战——这很好)。

​ 一种更有效的算法叫做 Sieve of Eratosthenes。有一个非常流行的c++套件，primseieve——但是构建起来相当复杂。相反，我发现一个更简单的实现更适合于我们的目的。您可以在http://wwwhomes.uni-bielefeld.de/achim/prime_sieve.html中找到它的源代码，但它也在git存储库中——https://github.com/freezer333/cppwebify-tutorial。

Node.js Express Web app

​ 在这一节中，我将使用完全相同的 Node.js的web应用程序。它是非常简单的，有一个HTML页面，有一些JavaScript (AngularJS)，它要求web服务器在用户指定的值下提供质数。web服务器使用一个JSON对象来响应，其中包含了primes，它使用了我将实现的几种技术之一。

​ 我假设读者对一个 Node.js web应用程序 有一些基本的理解，我在后台用Express和AngularJS创建了这个应用程序，但是我避开了任何复杂性和eye/candy，以免分散这些教程的目的。它也是一个很好的API到你的c++代码的设置-只是抛弃UI!

$ git clone https://github.com/freezer333/cppwebify-tutorial.git$ git checkout start

​ 你可以自己浏览网页应用——但相关的部分是前端——在/web/views 和后端找到的，在/index.js和 /routes中找到。

​ 让我们快速浏览一下/index.js。前十行左右只是样板代码:

var express = require('express');
var app = express();
var bodyParser = require('body-parser');app.use(express.static('public'));
app.set('view engine', 'jade');app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

​ 下一行是构建一个 “types” 数组——它最终将为post系列中的每个示例保留条目。现在，我们只有一个Node.js primesieve实现。

var types = [{title: "pure_node",description: "Execute a really primitive " + "implementation of prime sieve in Node.js"}];

​ 类型中的每个条目将对应于/route目录中找到的路由。这些是从 index.js动态加载，web服务器是由最后的一行代码开始的。

types.forEach(function (type) {app.use('/'+type.title, require('./routes/' + type.title));
});app.get('/', function (req, res) {res.render('index', { routes: types});
});var server = app.listen(3000, function () {console.log('Web server listing at http://localhost:%s', server.address().port);
});

​ 要启动web服务器，请导航到终端的 /web 目录并键入以下内容:

$ npm install
... dependencies will be installed
$ node index

​ 现在将浏览器指向http://localhost:3000。您将获得索引页，其中列出了实现选项。现在，您只需要一个选项——“pure_node”。单击它，您将看到一个带有单个数字框的页面。输入100并提交-和节点。primesieve的js实现将运行并返回100以下的所有质数。

​ 在 Node.js上的primesieve实现是在 routes/pure_node.js中。与我们将在本系列的其余部分中使用的C实现相比，它非常简单——但是它完成了任务!处理实际响应的代码是路由器的post方法:

router.post('/', function(req, res) {var under = parseInt(req.body.under); // from the uservar primes = find_primes(under);res.setHeader('Content-Type', 'application/json');res.end(JSON.stringify({results: primes}));
});

Automating + Node.js Web app

​ 如果您的c++独立于命令行运行——或者可以这样做——您可以使用Node的child process API运行它。这个选项适用于将任何东西带到web上——如果你只是运行它的话，你的命令行程序写在什么语言上并没有什么区别。

​ 自动化的两个特点使它具有吸引力。首先，由于在另一个进程中执行c++应用程序，所以实际上是异步地执行c++处理——这在web上是一个很大的胜利，因为您可以处理其他传入的HTTP流量，而c++应用程序正在工作。其次，你真的不需要做大量的语言集成或者使用复杂的V8 API——实际上这很简单!

​ 对于这个特定的部分，从git存储库签出 automation 标记。

$ git checkout automation

质数 C/C++分解器

​ 如上所述，我们正在构建 Sieve of Eratosthenes 素数计算策略筛选器的C实现的所有示例。这是一个很好的例子，因为速度对于质数来说很重要，而我所使用的C代码并不是你想要重写的类型。我所使用的示例——http://wwwhomes.uni-bielefeld.de/achim/prime_sieve.html——实际上是非常简单的，相比之下，更复杂的技术可以利用CPU缓存。到primesieve.org 去了解一下。对于Sieve的实现，程序的用户必须输入一个最大值，该算法将输出所有质数“在”这个值下。在本章的大部分内容中，我们将把这个输入值称为“under”。

​ 请先看一看最初的报价单。c代码现在在https://gist.github.com/freezer333/ee7c9880c26d3bf83b8e中找到，但是不要太纠结于细节，我们不需要过多地处理它(这就是重点!)。

primesieve.c

​ 当面对集成遗留（legacy ）程序时，您可能没有访问代码的特权。为了本章的目的，我将模拟一些常见的集成场景——我将编辑一些原始的 primesieve.c。

• 场景1:一个应用程序只从命令行参数中获取输入，并输出到标准输出。
• 场景2:一个应用程序从用户(stdin)中获取输入，并输出到标准输出。

• 场景3:从文件中获取输入并输出到另一个文件的应用程序。

  为了模拟每个场景，我们希望能够将FILE传递到主程序primesieve.c中，所以程序并不总是打印到控制台。让我们将 `main` 重命名为 `generate_args` ，并为其添加第三个参数FILE。我们将在场景3中具体使用它。
  

// in cppwebify-tutorial/cpp/prime4standalone/prime_sieve.c, 
// I've renamed int main(int argc, char *argv[])
// to:
int generate_args(int argc, char * argv[], FILE * out) {... complicated prime number stuff ...

​ 我将在另一个文件(main.cpp)中写入入口点，因此我也将 generate_args的声明添加到一个名为 prime_sieve.h的头文件中。

​ 我正在创建第二个函数- generate ，它提供一个简化的接口——它只接受“under”参数，而不是命令行参数。这个定义在 prime_sieve.c的底部。将参数转换为字符参数并调用 generate_args.。这只是为了让我不太编辑原始代码，并使场景2更简洁。显然，富有想象力的读者可以想出更好的方法来完成这一切:)

// at the bottom of cppwebify-tutorial/cpp/prime4standalone/prime_sieve.c,
// an adapter function for use when we aren't using command-line arguments
int generate(int under, FILE *out) {char * name = "primes";char param [50];sprintf(param, "%d", under);char * values[] = { name, param};generate_args(2, values, out);
}

​ 所以，我们剩下的是 prime_sieve.h -使用 extern C 来确保我们的C函数可以正确地与c++主文件集成，我将在示例中使用。

extern "C" {// the old main, renamed - with a third parameter"// to direct output to a file as neededint generate_args(int argc, char * argv[], FILE * out);// an adapter function when the caller hasn't// received under through command line argumentsint generate(int under, FILE * out);
}

The Node.js Child Process API

​ Node.js包含一个 child_process 模块，它公开了创建和控制进程的健壮的API。有三个基本的调用来创建新的子进程——每个进程都有自己的用例。

​ 第一个是 execFile，它接受(至少是)一个可执行程序的文件路径。您可以传递一个由程序调用的参数数组。函数的最后一个参数是当程序终止时要执行的回调。这个回调会有一个错误，一个stdout缓冲区，以及一个给定的 stderr缓冲区，它可以用来查询程序的输出。需要注意的是，这个回调只是在程序执行之后才调用。 execFile还返回一个表示子进程的对象，您可以将其写入stdin流。

// standard node module
var execFile = require('child_process').execFile// this launches the executable and returns immediately
var child = execFile("path to executable", ["arg1", "arg2"],function (error, stdout, stderr) {// This callback is invoked once the child terminates// You'd want to check err/stderr as well!console.log("Here is the complete output of the program: ");console.log(stdout)
});// if the program needs input on stdin, you can write to it immediately
child.stdin.setEncoding('utf-8');
child.stdin.write("Hello my child!\n");

​ 我发现，当您必须自动化一个具有定义良好的输入并以某种 “single phase”操作的应用程序时， execFile 函数是最好的，这意味着一旦您给它一些输入，它就会中断一段时间，然后转储所有的输出。这正是主程序的类型，因此我们将在本章中使用execFile。

​ child_process 模块有两个其他的函数来创建进程—— spawn 和 exec。 spawn 很像 execFile，它接受一个可执行文件并启动它。不同之处在于， spawn 将给您提供一个可用于stdout和stderr的可流接口。这对于更复杂的I/O场景非常有效，因为在您的node 代码和c++ app。 exec 非常类似于execFile， exec 通常用于shell程序(ls、pipes等)。

Synchronous选项

​ 在 Node.js v0.12引入了一套新的API ，它允许您同步执行子应用程序——当您启动子进程并在子进程终止之前，您的程序将会阻塞。如果您正在创建shell脚本，那么这是非常棒的，但它显然不是用于web应用程序的。对于我们的质数演示，当然，当我们得到一个用于质数的HTTP请求时，我们需要等待完整的输出，然后才能将结果页面提供给浏览器——但是我们应该能够在此期间继续为其他浏览器提供其他HTTP请求!除非您有一个非常具体的原因，否则您将希望在编写web服务器时远离spawnSync、 execSync和 execFileSync。

场景 1: C++ 带参启动

​ 最简单的 automate程序类型是一个程序，它将接受所有的输入作为命令行参数，并将其输出到stdout——因此我们将从这个场景开始。

​ 那么，让我们“想象一下”主程序是这样工作的(实际上，它已经基本做到了!)要使用该应用程序，我们可以键入:

$ primesieve 10
2
3
5
7
# {1 <= primes <= 10} = 4
0.000000000000  -3.464368964356

​ 我们会把所有的质数都印到屏幕上(每行一个)，再加上一些我们不需要的程序打印出来的额外信息。

​ 我将使输出易于在我的所有示例中解析——很明显，如果您的程序以一种严格的解析方式输出数据，那么您将有更多的工作要做。

用 node-gyp 编译 C++ 主程序

​ 我们的第一步是实际获得一个可执行的c++应用程序 cpp/prime4standalone独立的c++代码没有一个入口点——它只是质数生成代码，它将在我们所覆盖的所有3个场景中共享。在 cpp/standalone_stdio 中，我创建了一个入口点:

#include <iostream>
#include <stdio.h>
#include "prime_sieve.h"
using namespace std;int main(int argc, char ** argvs) {generate_args(argc, argvs, stdout);
}

下一步是构建c++可执行文件——将所有三个文件一起编译。

1. cpp/standalone_stdio/main.cpp

2. cpp/prime4standalone/prime_sieve.h

3. cpp/prime4standalone/prime_sieve.c

   ​如果您熟悉构建c++，那么无论您喜欢的编译器平台是什么，您都不会有问题。我们最终需要使用 node-gyp ——因为我已经用这种方式设置了所有c++的例子。

$ node-gyp configure build

​ 在 /cpp/standalone_stdio 你会找到一个 binding.gyp。这包含了用nodegyp构建这个特定示例所需的所有信息——将其视为Makefile。

{"targets": [{"target_name": "standalone","type": "executable","sources": [ "../prime4standalone/prime_sieve.c", "main.cpp"],"cflags": ["-Wall", "-std=c++11"],"include_dirs" : ['../prime4standalone'],"conditions": [[ 'OS=="mac"', {"xcode_settings": {'OTHER_CPLUSPLUSFLAGS' : ['-std=c++11','-stdlib=libc++'],'OTHER_LDFLAGS': ['-stdlib=libc++'],'MACOSX_DEPLOYMENT_TARGET': '10.7' }}]]}]
}

​ 让我们来介绍一些基础知识。我们只定义了一个目标((“standalone”)，因此它已经成为默认值。这里的type 非常关键，因为Node -gyp还可以编译动态库、静态库库、Node.js插件。将 type 设置为 executable ，告诉nodegyp创建一个标准的可运行的可执行文件。源数组包含我们的源(不需要header，但是可以添加)。由于在本节后面的许多c++代码都将使用c++ 11，所以我还在cflags 属性中传递了一些编译器标志。我还通过了OS X特定的东西，让c++ 11在Mac上使用XCode。这些特殊选项包含在 conditions 属性中，在Linux和Windows下被忽略。最后，我已经确保编译器可以通过在 include_dirs 属性下添加路径找到包含文件。

​ 我们的构建命令node-gyp configure build 操作的应该在cpp/standalone_stdio/build/Release 中创建一个 standalone可执行文件。您应该能够直接从命令行运行它。现在让我们从Node.js运行它。

Automating from Node.js

​ 前面我们设置了一个非常简单的Node.js web应用程序有一个单一的路由，可以使用纯JavaScript主程序实现计算质数。现在我们将创建第二个使用c++实现的 route 。

​ 首先在 cppwebify-tutorial/web/index.js 中，我们将在我们的类型数组中为新的c++路径添加一个新条目:

var types = [{title: "pure_node",description: "Execute a really primitive " + "implementation of prime sieve in Node.js"},{title: "standalone_args",description: "Execute C++ executable as a " + "child process, using command " +"line args and stdout.  " + "Based on /cpp/standalone_stdio"}];

​ 该类型数组用于创建路由，查找与 web/routes/目录中的每个 title 属性相同的文件:

types.forEach(function (type) {app.use('/'+type.title, require('./routes/' + type.title));
});

​ 现在，让我们在 /web/routes/standalone_args中添加我们的路由。如果您看一看，第1-9行基本上与 pure_nodeexample -第11行相同，在这里，我们将通过执行c++应用程序来响应实际用户对素数的请求:

router.post('/', function(req, res) {var execFile = require('child_process').execFile// we build this with node-gyp above...var program = "../cpp/standalone_stdio/build/Release/standalone";// from the browservar under = parseInt(req.body.under);var child = execFile(program, [under],function (error, stdout, stderr) {// The output of the prime_sieve function has // one prime number per line.  // The last 3 lines are additional information,// which we aren't using here - so I'm slicing // the stdout array and mapping each line to an int.// You'll want to be more careful parsing your // program's output!var primes = stdout.split("\n").slice(0, -3).map(function (line) {return parseInt(line);});res.setHeader('Content-Type', 'application/json');res.end(JSON.stringify({results: primes}));console.log("Primes generated from " + type);});
});

​ 在处理程序输出(以及处理来自浏览器的输入)时，您可能需要更健壮一些，因为您可以看到，调用子进程并返回对浏览器的响应非常简单。通过 node index.js 运行web应用程序。在 cppwebify-tutorial/web 下的终端中，将浏览器指向http://localhost:3000/。选择 “standalone_args”策略，您可以输入100以获得100以下的所有质数——这一次使用一个更快的基于c的实现!

场景 2: C++程序从标准输入获取数据

​ 很多程序会询问实际用户的输入。如果您能够访问您的程序的代码，那么可能很容易更改它，因此它接受这些输入作为命令行args——这意味着您可以只使用场景1中的策略。有时候这是行不通的——如果你连源代码都没有!当自动执行一个与用户对话的程序时，它也不起作用，你需要通过node来模拟。不过，不必担心——写入stdin非常简单，特别是如果您不需要等待来自子进程的任何输出(如果您这样做的话，请检查spawn 而不是 execFile )。

C++

​ 在 cpp/standalone_usr 中，我已经为一个c++程序创建了一个新的入口点，它简单地要求用户根据主程序的算法输入所需的参数。

#include <iostream>
#include <stdio.h>
#include "prime_sieve.h"
using namespace std;int main(int argc, char ** argvs) {int max;cout << "Please enter the maximum number:  ";cin  >> max;generate_primes(max, stdout);
}

​ 它包含了同样的 prime_sieve.h 文件作为场景1中的代码，并且具有非常相似的 binding.gyp 文件。在终端/独立终端上通过 node-gyp configure build 配置构建cpp/standalone_usr。

通过Node.js标准输入

​ 现在我们有了一个新的可执行的构建，它要求来自实时用户的输入。我们现在可以在我们的web应用程序中加入另一条路线来实现这一功能的自动化。在 web/index.js 中我们将创建另一个类型条目：

var types = [{title: "pure_node",description: "Execute a really primitive " + "implementation of prime sieve in Node.js"},{title: "standalone_args",description: "Execute C++ executable as a " + " child process, using command line "+" args and stdout.  " + " Based on /cpp/standalone_stdio"},{title: "standalone_usr",description: "Execute C++ executable as a " + " child process, using direct user input.  "+" Based on /cpp/standalone_usr"}];

​ 我们将在 web/routes/standalone_usr.js中创建一条新路由。在这个文件中，我们的代码将不再作为命令行参数传递，相反，我们将写入stdin：

router.post('/', function(req, res) {var execFile = require('child_process').execFile// notice we're pointing this to the new executablevar program = "../cpp/standalone_usr/build/Release/standalone_usr";var under = parseInt(req.body.under);// execFile will return immediately.var child = execFile(program, [],function (error, stdout, stderr) {// This function is executed once the program endsvar primes = stdout.split("\n").slice(0, -3).map(function (line) {return parseInt(line);});res.setHeader('Content-Type', 'application/json');res.end(JSON.stringify({results: primes}));console.log("Primes generated from " + type);});// now we write "under" to stdin so the C++ program // can proceed (it's blocking for user input)child.stdin.setEncoding('utf-8');child.stdin.write(under + "\n");// Once the stdin is written, the C++ completes // and the callback above is invoked.
});

现在你可能已经有了这个想法。再次启动web应用程序，现在您将在开始页面上有第三个条目——继续进行测试。

场景三 3: 从文件中输入 C++ 程勋

​ 我要讲的最后一个场景是，您正在自动化的程序从一个文件中获取输入，并将其输出转储到另一个文件中。当然，您的场景可能是这里讨论的三种场景的组合——您的场景可能涉及到输入/输出的固定文件名，或者指定的用户（通过stdin或命令行参数）。无论你的情况如何，你都可以应用这里的东西。

输入输出保存在文件中

​ 因此，第一步是将主程序变成类似于文件的程序。如果您看一下 cpp/standalone_flex_file，我已经创建了一个主程序的第三个入口点，它可以在命令行中接受输入/输出文件名。输入文件被假定为在第一行中简单地有 “under” 。输出文件将收到与之前的stdin相同的结果行。

#include <iostream>
#include <stdio.h>
#include "prime_sieve.h"using namespace std;// Simulating a legacy app that reads
// it's input from a user-specified file via command line
// arguments, and outputs to a similarly specified file.
int main(int argc, char ** argvs) {FILE * in = fopen(argvs[1], "r");int i;fscanf (in, "%d", &i);fclose(in);FILE * out = fopen(argvs[2], "w");generate_primes(i, out);fprintf(stdout, "Output saved in %s\n", argvs[2]);fclose(out);
}

​ 我们可以通过 node-gyp configure build 配置构建cpp/standalone_flex_file.这个C++程序。这将产生一个我们可以从node使用的目标可执行文件。

深入了解web文件读写

​ 在进入 Node.js之前，对于这个场景，我们来讨论一下基于文件的程序所涉及的挑战。大多数应用程序从来没有为web服务，它会读取指定的输入文件，并将其写入输出文件，就好像应用程序是唯一运行的一样。就好像它不是和同一个程序的另一个实例一起运行！当这些应用程序是手动运行的时候，这是有意义的——但是如果您将它们放在web上，您可以很容易地同时发出多个并发请求（来自不同的浏览器）。重要的是，这些同步执行的遗留C++程序不会相互冲突——您需要确保它们正在读取和写入它们自己的不同文件！

​ 当您无法访问遗留源代码时，这可能是说比做容易，特别是如果应用程序不允许用户指定文件（也就是说，它们在程序中是硬编码的！）如果它们是硬编码的，但是相对的文件路径，那么您可以使用当前的工作目录来玩操作，或者在每个传入的web请求的临时目录中创建可执行文件的副本（或链接到它）。这是一项昂贵的开销，但它确实有效。如果文件路径硬编码到绝对路径，那么您就有一个问题（找到代码！）

​ 我模拟了最简单（但最常见的）情况，其中输入和输出文件可以由用户指定（在本例中，通过命令行参数）。我们所需要做的就是确保启动C++应用程序的每个web请求都选择唯一的文件名——我通常通过在每个web请求上创建临时目录来实现这一点，将输入/输出文件放在临时目录中。这将保护每个正在运行的实例，同时保持输入/输出名称的一致性。

​ 现在让我们跳过Node.js 的路由。在 web/routes/standalone_file.js的顶部，我需要这个引入temp 模块，我用它来处理临时目录和文件的创建。它会在适当的位置放置你的平台的临时位置。

var temp = require('temp');

​ 下面是在 web/routes/standalone_file.js中实现的路由代码。

router.post('/', function(req, res) {var execFile = require('child_process').execFilevar program = "../cpp/standalone_flex_file/build"+"/Release/standalone_flex_file";var under = parseInt(req.body.under);// Create a temporary directory, with // node_example as the prefixtemp.mkdir('node_example', function(err, dirPath) {// build full paths for the input/output filesvar inputPath = path.join(dirPath, 'input.txt');var outputPath = path.join(dirPath, 'output.txt');// write the "under" value to the input filesfs.writeFile(inputPath, under, function(err) {if (err) throw err;// once the input file is ready, execute the C++ // app with the input and output paths // specified on the command linevar primes = execFile(program, [inputPath, outputPath], function(error) {if (error ) throw error;fs.readFile(outputPath, function(err, data) {if (err) throw err;var primes = data.toString().split('\n').slice(0, -3).map(function (line) {return parseInt(line);});res.setHeader('Content-Type', 'application/json');res.end(JSON.stringify({results: primes}));exec('rm -r ' + dirPath, function(error) {if (error) throw error;console.log("Removed " + dirPath);})});});});});
});

​ 上面的代码首先创建临时目录。然后，它编写输入文件，并以输入和输出文件路径作为命令行参数启动子进程。一旦流程完成，我们将读取输出文件以获得结果，并像以前一样将其返回给浏览器。最后，我们通过删除父目录来清理临时文件。这一点很重要，因为即使临时模块允许跟踪和自动删除临时文件，它只会在进程终止时清除这些文件。由于这是一个web应用程序，我们将（希望！）等待很长一段时间才会发生这种情况。

​ 正如您所看到的，这段代码将受益于更好的控制流模式（async, promises, etc）。我试着坚持最低限度，我把这个留给你们：）。

​ 除了上面的route 之外，我已经将这个最终场景添加到 web/index.js的 types数组中，你可以启动你的web应用程序，并像其他的一样测试这个。

Node.js直接调用已经存在的C++ DLL

​ 本节将完全集中于将您的C++编译成一个共享库或DLL，并从Node.js调用该代码。使用 FFI。我还将讨论在尝试将遗留C++应用程序转换成可调用共享库时遇到的一些常见问题。

​ 当使用automation一个C++应用程序时，您有一个优势，那就是在JavaScript和C++之间进行真正的分离。automation还允许您与几乎所有的编程语言进行集成——只要它可以通过stdin/stdout或输入和输出文件实现automation。一个缺点是，实际上只有一个入口点到你的C++-main。您当然可以在C++和节点应用程序之间开发复杂的协调，但是当您只想向C++发送一些输入并等待结果时，automation是最有效的。

​ 通常您需要细粒度控制和协调 Node.js和c++。你希望能够通过函数调用C++，而不仅仅是一个可执行的入口点。此外，您希望能够从这些函数中获得输出作为返回值（或参考参数），而不是从stdout或某个输出文件中获取输出。

​ 在这种情况下，共享库（或DLL）是一个很好的解决方案。如果您的C++已经在一个DLL中，那么您可以立即开始——但是如果不是，您通常可以很容易地将您的遗留代码编译成一个DLL——您只需要知道您希望向调用者公开哪些方法/函数。一旦您有了一个DLL，就可以通过 Node.js很简单使用接口（继续读下去！）

​ 当automation过于繁琐时，将遗留的C或C++应用程序转换为DLL是一个很好的集成选择。它还可以让您避免使用V8 API开发Node的复杂性，这并不总是微不足道的。

对于这个特定的部分，请签出dll标签

​ 一旦您签出了代码，请花一点时间来检查我设置的目录结构。在/cpp 目录中，我将所有为automation示例开发的C++应用程序都放在了这里，在 /cpp/prime4standalone单机中使用了素数生成的共享源。现在，我们需要修改质数代码，使其能够很好地作为一个DLL，我将把代码放入 /cpp/prime4lib中。与前面的情况一样，示例web应用程序在 web中。我们将在这篇文章中添加一条路由（ffi)）——用于共享库实现。

C++ 动态库

​ 如果您试图将现有的共享库集成到Node.js中，然后你可以跳过这部分——你都准备好了！如果您有一些遗留的C++代码，它最初是一个独立的应用程序（或者一部分），那么您需要先准备好代码作为共享库。这样做的主要考虑是定义您的API——由主机代码（在我们的例子中，node.js）可以调用的一系列函数。也许您的C++已经组织好了，这些功能已经准备好了——但是您可能需要进行一些重组。

​ 另一个主要考虑因素是如何获得C++代码的输出。例如，在automation时，我从Node运行了一堆独立的primesieve应用程序，每个应用程序都可以直接输出到标准输出或输出文件。不过，我们不希望共享库——我们希望输出返回给调用者。要做到这一点，你可能需要有点创意——我将向你展示我在下面这一节中是如何做到的。

​ 这是我想要共享库支持的API。实际上，它并不是一个API——它只是一个函数！

int getPrimes(int under, int primes[]);

​ 第一个参数表示最大值——这样我们就能找到这个值下的所有质数。质数将被塞进第二个参数——一个数组。假设这个数组有足够的空间来储存所有生成的质数(under 是一个好的”maximum”大小）。这个函数会返回实际找到的质数数目。

捕捉输入

​ 现在让我们看一下自动化示例中的代码。在 /cpp/prime4standalone中， primesieve.c 文件有一个主要功能：

int generate_args(int argc, char * argv[], FILE * out)

​ 它还有一个适配器功能，可以用 under.替换argc/argv参数。在这两种情况下，请注意输出是通过 fprintf把结果写进引用类型参数out 。对于我们的API，我们希望将输出放在一个数组中。

​ 一种方法可能是开始对底层的primesieve实现进行修改，用一些代码替换 fprintf 调用来加载一个数组。这是可以工作的（特别是如果这是新的C++代码，或者至少是C++，这是相当简单的），但是它不是特别可伸缩的（如果您需要执行一些更复杂的操作来捕获输出呢？）我发现对遗留程序进行修改是最好的，当您保持简单的更改时——这就是我在这里要做的。

数据类型C++转换类

​ 就像生活中的大多数事情一样，保持一件简单的事情往往会让事情变得更复杂。我的目标是在现有的primeseive代码中替换每个 fprintf 语句，并使用一个类似的简单函数：

void pass(int prime);

​ 我希望发送函数能够将素数添加到一个数组中，数组是从调用的Node.js中发送过来的。

// called from Node.js - calls to send should add prime to primes
int getPrimes(int under, int primes[]);

​ 这看起来很简单，我们可以通过发送一个对象的成员方法来获得这样的东西，该对象可以引用数组。不过，primeseive是直接的C代码，这让事情变得复杂起来。

​ 让我们从交换的数据交换类 exchange.h：

#define _exchangeclass
#include <iostream>
#include <functional>
using namespace std;class exchange {
public:exchange(const std::function<void (void * )> & c) {this->callback = c;}void send(int data){this->callback(&data);}
private:std::function<void (void * )> callback;
};#include "c_exchange.h"

​ 您首先要注意的是，该类本身并不包含对数组的引用。为了保持它的一般化，我只是让它拥有一个回调函数——它将负责在本例中存储给定值给数组，但是可以做任何事情。

​ 注意最后一行——我包括一个单独的头文件，叫做 c_exchange.h。send 成员不能从C代码（primesieve）中调用，您可能已经猜到了， c_exchange.h 包含一个函数来解决这个问题。让我们看看里面：

#ifdef _exchangeclass
extern "C" {
#endifvoid pass(void * exchanger, int data);#ifdef _exchangeclass
}
#endif

​ 首先，这个头将被C++和C代码包含进来。 exchange.h它声明交换类定义了交换器符号——所以第一行就是exchangeclass标识是否已经定义。如果是，将从C调用的 pass function 包装在一个 extern 块中。

​ pass 函数接受一个指向交换对象的指针（(void *，因为 exchange 类对C调用者是不可见的）。在定义中，找到 exchange.cpp，我们看到这个指针被转换回一个exchange 对象，send方法被调用：

void pass(void * exchanger, int data) {exchange * xchg = (exchange * ) exchanger;xchg->send(data);
}

​ 这有点复杂，但是 exchange 类和它的独立 pass 助手函数可以被放入几乎任何现有的C++或C遗留程序中，只要将一个指针指向一个 exchange对象到遗留代码，并通过 pass替换输出调用即可。让我们用 primesieve.c来做这个。

修改质数分解服务

​ 在 /cpp/prime4lib 中有一个修改过的 primesieve.h和 primesieve.c。 old primesieve.h定义了以下两个函数：

// primeseive.h for standalone programs
int generate_args(int argc, char * argv[], FILE * out);
int generate_args(int under, FILE * out);

​ 现在我用下面的签名替换了这些签名：

// primesieve.h for library calls
int generate_args(int argc, char * argv[], void * out);
int generate_args(int under, void * out);

​ primeseive.c 内部。旧的独立代码有一个 #define设置来使用fprintf，在第43行（注意，我不是原始的 l primsieve code 的作者——我不知道这个复杂的打印方案背后的历史或意图。和大多数传统应用一样，有时候这些问题最好还是没有被要求！）我们现在用一个 pass(out, x)调用来替换 fprintf(out, UL"\n",x) 。

动态库入口

​ 现在我们有了一个primesieve.h/primeseive.c 使用 pass的c实现，我们只需要创建一个C++入口点来创建一个 exchange 对象并调用primesieve代码。我已经在/cpp/lib4ffi/primeapi.h 和 /cpp/lib4ffi/primeapi.cpp中完成了这个任务。

​ primeapi.h 是共享库入口点，它有我想要的库API函数的声明：

extern C {int getPrimes(int under, int primes[]);
}

​ 实现使用 exchange 类，lambda函数作为回调函数。正如您所看到的，lambda函数会将发送到数组的任何数据添加到数组中。

int getPrimes(int under, int primes[]) {int count = 0;exchange x([&](void * data) {int * iptr = (int * ) data;primes[count++] = * iptr;});generate_primes(under, (void*)&x);return count;
}

​ 现在，当我们调用 primesieve.h中定义的 generate_primes。我们把我们的exchange作为参考。在 primesieve.c 中 out是对exchange 对象的引用。在 primesieve.c 中所有 pass(out, x) 调用都是通过out对象为 exchange对象（在 exchange.cpp）中，并且回调（lambda）被触发。最终的结果是，primesieve计算的所有值都在素数数组中找到。

通过gyp链接C++动态度

​ 我们现在需要构建我们的共享库。幸运的是，我们习惯使用的工具集—— node-gyp ——也可以帮助我们。在 /cpp/lib4ffi 中，您将找到另一个名为binding.gyp的配置文件。它与自动化示例中的独立示例中的gyp文件非常相似，但是它链接了 /cpp/prime4lib中的primesieve文件，而不是 /cpp/prime4standalone ，它的构建类型是shared_library 而不是 executable。

​ 构建类的动态库和通过通过 node-gyp configure build 构建 cpp/lib4ffi类似。这将生成一个我们可以从node使用的目标共享库。共享库将在/cpp/lib4ffi/build/Release 中——具有特定于您的操作系统的扩展（即。’在OS X上的ie. prime.dylib，在Windows 是prime.dll)。

FFI

​ 所有这些工作，我们有一个共享库——现在让我们从node.js中调用它。要做到这一点，我们将使用Node的Foriegn Function Interface (node-ffi).。node-ffi是一个 Node.js addon使用纯JavaScript加载和调用动态库。你可以在 https://github.com/node-ffi/node-ffi/wiki/Node-FFI-Tutorial 找到一个优秀的教程，它可以更详细地介绍它。特别地，签出 async 部分，它向您展示了如何使用libuv在自己的线程中轻松调用共享库方法，这样就不会阻塞主Node.js事件循环!

​ 使用 node-ffi 的一个关键部分是掌握ref模块，以便在 Node.js上构建原生数据类型， Buffer object（附录B的主题）。这些数据类型（int, arrays, etc.）允许您与在共享库中找到的本机函数进行交互。

​ 我们的API只有一个调用，它使用两个整数和一个整数数组来返回类型和参数：

int getPrimes(int under, int primes[]);

​ 简单的整数并不要求我们做很多事情（node-ffi自动转换成JavaScript数字类型），但是我们确实需要分配一个整数数组来保存我们的结果。这是我们如何用 ref来做的

var ArrayType = require('ref-array');
var IntArray = ArrayType(int);
var a = new IntArray(10); // creates an integer array of size 10

​ 接下来，我们使用 ref 数据类型标识符和 node-ffi 来定义我们类库的接口：

var ffi = require('ffi')
var ref = require('ref')
var int = ref.types.intvar libprime = ffi.Library('../cpp/lib4ffi/build/Release/prime', {'getPrimes': [ int, [ int, IntArray] ]
})

​ libprime 变量现在代表我们在上一节中创建的共享库中找到的get素数函数。我们可以调用这个函数，它的返回类型可以保存在一个普通的JavaScript number变量中。我们可以用返回的计数从IntArray中提取素数——给出10以下的素数。

var count = libprime.getPrimes(under, a);
var primes = a.toArray().slice(0, count);

集成

​ 现在我们有了共享库和Node.js代码可以调用它，让我们把它封装到我们不断增长的web应用程序示例中自己的路线中。在 /web/index.js 文件，我们将为一个名为 ffi的路由添加另一个路由。

var types = [{title: "pure_node",description: "Execute a really primitive " + " implementation of prime sieve in Node.js"},... the entries for the automation example routes...{title: "ffi",description: "Using Node Foreign Function " + " Interface (ffi) to call C++ code.  Based on /cpp/lib4ffi"}];

​ 该类型数组用于创建路由，方法是查找一个以web/routes/目录中的每个 title 属性命名的文件：

types.forEach(function (type) {app.use('/'+type.title, require('./routes/' + type.title));
});

​ 现在让我们在 /web/routes/ffi.js中添加我们的路线。下面是相关的post处理程序，它看起来很像上面的ffi示例：

router.post('/', function(req, res) {var ffi = require('ffi')var ref = require('ref')var ArrayType = require('ref-array')var int = ref.types.intvar IntArray = ArrayType(int)// The under parameter is coming from /// the user input (form)var under = parseInt(req.body.under);var a = new IntArray(under);// Create the interface to our shared libraryvar libprime = ffi.Library('../cpp/lib4ffi/build/Release/prime', {'getPrimes': [ int, [ int, IntArray] ]})// call the prime number code and extract // the array of primes.var count = libprime.getPrimes(under, a);var primes = a.toArray().slice(0, count);// send the primes right back to the // browser for displayres.setHeader('Content-Type', 'application/json');res.end(JSON.stringify({results: primes}));
});

​ 从 /web 并选择ffi选项，通过键入 node index.js 来启动你的web应用程序。输入100，点击”submit” ，你应该在屏幕上看到低于100的质数，这一次是由dll/共享库生成的。

异步C++ Addon（Nan）

​ 这本书是专门为C++插件而写的，所以这一节是另一个例子，但这是一个很好的例子，可以比较许多其他的选择。读了这本书之后，你可能会倾向于选择addon路线，但确实有充分的理由不去做。如果您没有访问遗留C++应用程序的源代码，那么automation是您最好的选择——您将无法创建节点类型。我将在这里描述。当然，如果您的遗留代码不是C或C++，那么自动化也可能是您最好的选择（尽管实际上也有从 Node到其他语言的bindings）。如果您的c/c++代码已经在dll或共享库中，那么当然，使用FFI是最有意义的，如上所述。

​ 如果您有完全的访问（并且是舒适的编辑）您的目标是c/c++，那么创建一个原生的addon可能是最强大的方法。首先，如果您的代码已经组织得很好（明确定义了条目和输出/返回点），那么创建addon本身并不困难——尤其是使用Nan。其次，addons非常灵活——它们可以是块/同步或异步的，并且支持大多数用例（即传递/返回的对象、数组等）。最后，当您创建一个 Node.js addon，您的JavaScript代码比使用自动化或共享库方法更干净——您将通过比较本文章中的JavaScript代码与本系列中的其他文章进行比较。

​ 对于这个特定的部分，签出addon标签。

Addon

​ 让我们创建我们的C++addon文件- /cpp/nodeprime_sync/addon.cpp。我们将在 /cpp/prime4lib 中找封装 getPrimes函数，并使用V8和Nan中定义的宏将其注册到V8中。首先，我们将包括primesieve代码的头文件，我们用来从原始代码中收集数据的 exchange类，以及V8/Nan：

#include <nan.h>  // includes v8 too
#include <functional>
#include <iostream>// class to hold values returned from primesieve
#include "exchange.h"  
#include "prime_sieve.h"// bring in the required namespaces
using namespace Nan;
using namespace v8;
using namespace std;

​ 现在我们来创建一个函数来做计算。从共享的库帖子中可以了解到很多信息，我们将使用 exchange 类来收集primesieve的输出。主要的区别在于，我们将把这些数据收集到一个V8本地数组中，这样就可以将数据全部返回给调用的JavaScript代码。在深入到C++之前，下面是展示如何在JavaScript中使用函：

var primes = primenode.getPrimes(under);
// primes is now the array of all prime numbers less than under

C++:

NAN_METHOD(CalculatePrimes) {Nan:: HandleScope scope;int under = To<int>(info[0]).FromJust();v8::Local<v8::Array> results = New<v8::Array>(under);int i = 0;exchange x([&](void * data) {Nan::Set(results, i, New<v8::Number>(*((int *) data)));i++;});generate_primes(under, (void*)&x);info.GetReturnValue().Set(results);
}

​ 在我们提取必要的参数并为我们的结果创建一个数组之后，我们使用 exchange类。我们正在创建一个回调，primesieve（(generate_primes）将在每次找到质数时调用它。在这里，我们不是将每个质数都添加到一个vector，而是将它添加到我们声明的本地V8数组中。注意，这个数组将是 “oversized”,，因为如果”under”是100，那么显然不是100个质数小于100！没有显式设置的每个元素在稍后通过JavaScript访问时都将被设置为未定义。我们现在调用primesieve实现，它通过交换对象执行并增量地填满数组。

int i = 0;
exchange x([&](void * data) {Nan::Set(results, i, New<v8::Number>(*((int *) data)));i++;});generate_primes(under, (void*)&x);

​ 最后，我们需要用V8来注册这个函数(CalculatePrimes) ，我们在文件的底部做这个：

NAN_MODULE_INIT(Init) {Nan::Set(target, New<String>("getPrimes").ToLocalChecked(),GetFunction(New<FunctionTemplate>(CalculatePrimes)).ToLocalChecked());
}NODE_MODULE(addon, Init)

编译addon

binding.gyp :

{"targets": [{"target_name": "nodeprime","sources": [ "../prime4lib/prime_sieve.c", "../prime4lib/exchange.cpp", "addon.cpp"],"cflags": ["-Wall", "-std=c++11"],"include_dirs" : ['../prime4lib', "<!(node -e \"require('nan')\")"],"conditions": [ [ 'OS=="mac"', { "xcode_settings": { 'OTHER_CPLUSPLUSFLAGS' : ['-std=c++11','-stdlib=libc++'], 'OTHER_LDFLAGS': ['-stdlib=libc++'], 'MACOSX_DEPLOYMENT_TARGET': '10.7' } }] ] }]
}

​ 在这个 bindings文件中有一些新东西。首先，请注意，没有“type”属性——默认情况下，node-gyp构建一个 Node.js addon——所以不需要指定任何东西。我已经将目标定义为 nodeprime,，而构建的输出最终将成为nodeprime.node。除了指定构建文件和primesieve的include目录之外，我还将Nan添加到include目录集——使用node shell命令。其余的（条件）与前一篇文章的编译器是相同的，主要是为了支持C++11。

​ 要构建，在 /cpp/nodeprime_sync执行 node-gyp configure build的编译命令。 nodeprime.node 文件将位于 /cpp/nodeprimes_sync/build/Release-我们将在稍后链接到。

JavaScript调用

​ 现在是最简单的部分！首先，我们需要这个模块。我们在require命令中指定一条路径

var nodeprime = require("[relative path to code]" + + "/cpp/nodeprime_sync/build/Release/nodeprime")

​ 现在要得到100以下的质数，调用函数

var retval = primes.getPrimes(100);
console.log(retval);

​ retval 现在只是一个JavaScript数组——但是你会看到有100个元素（大部分是空的），因为我们在C++中过度分配了。我们可以很容易地摆脱它：

var retval = primes.getPrimes(100).filter(function(val) { return val != undefined});
console.log(retval);

Addon （non-blocking）

​ 如果您正在集成一个web应用程序，那么同步代码是一个真正的问题。如果上面的JavaScript代码是响应HTTP请求而执行的，那么在返回数组之前，不会处理其他请求。我们对addon编码的方式，C++代码在 Node.js事件循环中执行。使用异步模型会好得多！

​ 我在 /cpp/nodeprime中创建了异步addon。在该文件夹中，您将看到一个package.json文件（您需要执行npm install命令）来设置Nan。您还将看到类似的 binding.gyp 文件。像以前一样，还有一个addon.cpp文件包含异步addon。

​ 首先,在 addon.cpp中，您将看到顶部部分（includes/namespaces）和底部部分（NAN_METHOD 和NODE_MODULE）是完全相同的。现在的变化是如何实现 CalculatePrimes ，以及增加了继承了 AsyncWorker 的 PrimeWorker类，并包含了完成工作的所有逻辑。在深入研究之前，让我们看看调用JavaScript代码最终会是什么样子：

// Asynchronously get all prime numbers under 100
nodeprime.getPrimes(100, function (err, primes) {console.log(primes);
});

​ 请注意t getPrimes 现在得到两个参数，“under”和一个回调函数，当它完成时接收结果。这就是我们从C++开始的地方，因为我们需要对那个回调进行引用，这样我们就可以调用它：

NAN_METHOD(CalculatePrimes) {int under = To<int>(info[0]).FromJust();Callback *callback = new Callback(info[1].As<Function>());AsyncQueueWorker(new PrimeWorker(callback, under));
}

​ 请注意， CalculatePrimes 会提取两个参数——在 under和callback。现在，我们没有实际计算质数，而是用我们的PrimeWorker 类的实例创建了一个 AsyncQueueWorker 。我们的 PrimeWorker 类是在调用回调和 under参数创建的，因为它们将被用来处理工作。 AsyncQueueWorker 立即返回——它只是简单地对工人进行排队。C++现在将控制权返回给调用的JavaScript代码。

​ 现在让我们看看在 PrimeWorker 类内部到底发生了什么。构造函数非常简单——最重要的是，它使用JavaScript中发送的回调初始化基类AsyncWorker 。在 PrimeWorker,中也保存了under 值，并且初始化了质数的质数vector。

PrimeWorker(Callback *callback, int under): AsyncWorker(callback), under(under), primes(0) {}

​ 这是与同步addon有很大区别的地方——我们将在标准的C++向量中保存素数，而不是直接进入V8本地数组。这是因为素数是在一个工作者线程中计算的，而不是在事件循环中计算的。

​ 一旦我们从 CalculatePrimes中调用 AsyncQueueWorker ，libuv将把我们的 PrimeWorker 对象发送到一个工作线程上，并调用它的Execute 方法——如下所示：

void Execute () {exchange x([&](void * data) {primes.push_back(*((int *) data));});generate_primes(under, (void*)&x);
}

​ 这几乎就是 CalculatePrimes的同步版本所做的——它只是在工作线程中执行。一旦 Execute 完成，libuv将自动在事件循环中 通过 PrimeWorker 调用HandleOKCallback 方法。

void HandleOKCallback () {Nan:: HandleScope scope;v8::Local<v8::Array> results = New<v8::Array>(primes.size());int i = 0;for_each(primes.begin(), primes.end(),[&](int value) {Nan::Set(results, i, New<v8::Number>(value));i++;});Local<Value> argv[] = { Null(), results };callback->Call(2, argv);
}

​ 因为这个方法实际上是在Node事件循环线程中调用的，所以我们可以分配一个V8 Local Array，它将返回给JavaScript。我们创建一个范围，初始化一个数组（这一次，正好是正确的大小，因为我们已经有了带有素数的向量）。接下来，我们使用for_each 来填充数组。

​ 最后一步是实际调用作为初始参数发送给addon的JavaScript回调。我们打包一个参数数组来表示参数（首先是Null，因为没有错误，然后是数组）。最后，我们将执行回调——在此期间，控制再次被发送回JavaScript。

​ 您需要再做一次r node-gyp configure build 来构建这个模块，现在我们可以从node.js调用它。

JavaScript调用

​ 如上所示，我们现在只需要要求模块：

var nodeprime = require("[relative path to code]" + "/cpp/nodeprime/build/Release/nodeprime")

​ 现在要得到100以下的质数，只需调用函数——传入一个回调，一旦生成了素数，就会调用它：

primes.getPrimes(100, function (err, primes){console.log(primes);
});

集成

​ 好吧……让我们把这个放到我们正在开发的网页应用上。我将向您展示异步版本，因为同步模型在web上并不能很好地发挥作用。

​ 在 /web/index.js 文件，我们将为一个名为 ffi的路由添加另一个条目。

var types = [{title: "pure_node",description: "Execute a really primitive " + "implementation of prime sieve in Node.js"},//... the entries for the automation and shared library{title: "addon",description: "Creating a Node Addon that can " +"be called like any other module.  Based on /cpp/nodeprime"}];

​ 该类型数组用于创建路由，方法是查找一个以web/routes/目录中的每个title 属性命名的文件：

types.forEach(function (type) {app.use('/'+type.title, require('./routes/' + type.title));
});

​ 现在让我们在 /web/routes/addon.js中添加我们的路线。下面是相关的post处理程序，它看起来很像我们已经看到的代码：

router.post('/', function(req, res) {var under = parseInt(req.body.under);primes.getPrimes(under, function (err, primes) {res.setHeader('Content-Type', 'application/json');res.end(JSON.stringify({results: primes}));});console.log("Primes generated using " + type);
});

​ 启动web应用程序（在 /web通过node index 启动网站），尝试 addon的链接。没有惊喜。