我们知道，Node.js 不适合 CPU 密集型计算的场景，通常的解决方法是用 C/C++ 编写 Node.js 的扩展（Addons）。以前只能用 C/C++，现在我们有了新的选择——Rust。

3.5.1 环境

3.5.2 Rust

Rust 是 Mozilla 开发的注重安全、性能和并发的现代编程语言。相比较于其他常见的编程语言，它有 3 个独特的概念：

  1. 所有权
  2. 借用
  3. 生命周期

正是这 3 个特性保证了 Rust 是内存安全的，这里不会展开讲解，有兴趣的读者可以去了解一下。

接下来，我们通过三种方式使用 Rust 编写 Node.js 的扩展。

3.5.3 FFI

FFI 的全称是 Foreign Function Interface，即可以用 Node.js 调用动态链接库。

运行以下命令：

  1. $ cargo new ffi-demo && cd ffi-demo
  2. $ npm init -y
  3. $ npm i ffi --save
  4. $ touch index.js

部分文件修改如下：

src/lib.rs

  1. #[no_mangle]
  2. pub extern fn fib(n: i64) -> i64 {
  3.   return match n {
  4.     1 | 2 => 1,
  5.     n => fib(n - 1) + fib(n - 2)
  6.   }
  7. }

Cargo.toml

  1. [package]
  2. name = "ffi-demo"
  3. version = "0.1.0"
  5. [lib]
  6. name = "ffi"
  7. crate-type = ["dylib"]

Cargo.toml 是 Rust 项目的配置文件，相当于 Node.js 中的 package.json。这里指定编译生成的类型是 dylib（动态链接库），名字在 *inux 下是 libffi，Windows 下是 ffi。

使用 cargo 编译代码：

  1. $ cargo build #开发环境用
  2. 或者
  3. $ cargo build --release #生产环境用，编译器做了更多优化，但编译慢

cargo 是 Rust 的构建工具和包管理工具，负责构建代码、下载依赖库并编译它们。此时会生成一个 target 的目录，该目录下会有 debug（不加 —release）或者 release（加 —release）目录，存放了生成的动态链接库。

index.js

  1. const ffi = require('ffi')
  2. const isWin = /^win/.test(process.platform)
  4. const rust = ffi.Library('target/debug/' + (!isWin ? 'lib' : '') + 'ffi', {
  5.   fib: ['int', ['int']]
  6. })
  8. function fib(n) {
  9.   if (n === 1 || n === 2) {
  10.     return 1
  11.   }
  12.   return fib(n - 1) + fib(n - 2)
  13. }
  15. // js
  16. console.time('node')
  17. console.log(fib(40))
  18. console.timeEnd('node')
  20. // rust
  21. console.time('rust')
  22. console.log(rust.fib(40))
  23. console.timeEnd('rust')

运行 index.js：

  1. $ node index.js
  2. 102334155
  3. node: 1053.743ms
  4. 102334155
  5. rust: 1092.570ms

将 index.js 中 debug 改为 release，运行：

  1. $ cargo build --release
  2. $ node index.js
  3. 102334155
  4. node: 1050.467ms
  5. 102334155
  6. rust: 273.508ms

可以看出：添加了 —release 编译后的代码，执行效率提升十分明显。

3.5.4 Neon

官方介绍：

Rust bindings for writing safe and fast native Node.js modules.

使用方法如下：

  1. $ npm i neon-cli -g
  2. $ neon new neon-demo
  3. $ cd neon-demo
  4. $ tree .
  5. .
  6. ├── README.md
  7. ├── lib
  8. │   └── index.js
  9. ├── native
  10. │   ├── Cargo.toml
  11. │   ├── build.rs
  12. │   └── src
  13. │       └── lib.rs
  14. └── package.json
  16. 3 directories, 6 files
  17. $ npm i #触发 neon build
  18. $ node lib/index.js
  19. hello node

接下来我们看看关键的代码文件。

lib/index.js

  1. var addon = require('../native');
  2. console.log(addon.hello());

native/src/lib.rs

  1. #[macro_use]
  2. extern crate neon;
  4. use neon::vm::{Call, JsResult};
  5. use neon::js::JsString;
  7. fn hello(call: Call) -> JsResult<JsString> {
  8.     let scope = call.scope;
  9.     Ok(JsString::new(scope, "hello node").unwrap())
  10. }
  12. register_module!(m, {
  13.     m.export("hello", hello)
  14. });

native/build.rs

  1. extern crate neon_build;
  3. fn main() {
  4.     neon_build::setup(); // must be called in build.rs
  6.     // add project-specific build logic here...
  7. }

native/Cargo.toml

  1. [package]
  2. name = "neon-demo"
  3. version = "0.1.0"
  4. authors = ["nswbmw <gxqzk@126.com>"]
  5. license = "MIT"
  6. build = "build.rs"
  8. [lib]
  9. name = "neon_demo"
  10. crate-type = ["dylib"]
  12. [build-dependencies]
  13. neon-build = "0.1.22"
  15. [dependencies]
  16. neon = "0.1.22"

在运行 neon build 时，会根据 native/Cargo.toml 中 build 字段指定的文件（这里是 build.rs）编译，并且生成的类型是 dylib（动态链接库）。native/src/lib.rs 存放了扩展的代码逻辑，通过 register_module 注册了一个 hello 方法，返回 hello node 字符串。

接下来测试原生 Node.js 和 Neon 编写的扩展运行斐波那契数列的执行效率。

修改对应文件如下：

native/src/lib.rs

  1. #[macro_use]
  2. extern crate neon;
  4. use neon::vm::{Call, JsResult};
  5. use neon::mem::Handle;
  6. use neon::js::JsInteger;
  8. fn fib(call: Call) -> JsResult<JsInteger> {
  9.   let scope = call.scope;
  10.   let index: Handle<JsInteger> = try!(try!(call.arguments.require(scope, 0)).check::<JsInteger>());
  11.   let index: i32 = index.value() as i32;
  12.   let result: i32 = fibonacci(index);
  13.   Ok(JsInteger::new(scope, result))
  14. }
  16. fn fibonacci(n: i32) -> i32 {
  17.   match n {
  18.     1 | 2 => 1,
  19.     _ => fibonacci(n - 1) + fibonacci(n - 2)
  20.   }
  21. }
  23. register_module!(m, {
  24.   m.export("fib", fib)
  25. });

lib/index.js

  1. const rust = require('../native')
  3. function fib (n) {
  4.   if (n === 1 || n === 2) {
  5.     return 1
  6.   }
  7.   return fib(n - 1) + fib(n - 2)
  8. }
  10. // js
  11. console.time('node')
  12. console.log(fib(40))
  13. console.timeEnd('node')
  15. // rust
  16. console.time('rust')
  17. console.log(rust.fib(40))
  18. console.timeEnd('rust')

运行：

  1. $ neon build
  2. $ node lib/index.js
  3. 102334155
  4. node: 1030.681ms
  5. 102334155
  6. rust: 270.417ms

接下来看一个复杂点的例子，用 Neon 编写一个 User 类，可传入一个含有 first_name 和 last_name 的对象，暴露出一个 get_full_name 方法。

修改对应文件如下：

native/src/lib.rs

  1. #[macro_use]
  2. extern crate neon;
  4. use neon::js::{JsFunction, JsString, Object, JsObject};
  5. use neon::js::class::{Class, JsClass};
  6. use neon::mem::Handle;
  7. use neon::vm::Lock;
  9. pub struct User {
  10.   first_name: String,
  11.   last_name: String,
  12. }
  14. declare_types! {
  15.   pub class JsUser for User {
  16.     init(call) {
  17.       let scope = call.scope;
  18.       let user = try!(try!(call.arguments.require(scope, 0)).check::<JsObject>());
  19.       let first_name: Handle<JsString> = try!(try!(user.get(scope, "first_name")).check::<JsString>());
  20.       let last_name: Handle<JsString> = try!(try!(user.get(scope, "last_name")).check::<JsString>());
  22.       Ok(User {
  23.         first_name: first_name.value(),
  24.         last_name: last_name.value(),
  25.       })
  26.     }
  28.     method get_full_name(call) {
  29.       let scope = call.scope;
  30.       let first_name = call.arguments.this(scope).grab(|user| { user.first_name.clone() });
  31.       let last_name = call.arguments.this(scope).grab(|user| { user.last_name.clone() });
  32.       Ok(try!(JsString::new_or_throw(scope, &(first_name + &last_name))).upcast())
  33.     }
  34.   }
  35. }
  37. register_module!(m, {
  38.   let class: Handle<JsClass<JsUser>> = try!(JsUser::class(m.scope));
  39.   let constructor: Handle<JsFunction<JsUser>> = try!(class.constructor(m.scope));
  40.   try!(m.exports.set("User", constructor));
  41.   Ok(())
  42. });

lib/index.js

  1. const rust = require('../native')
  2. const User = rust.User
  4. const user = new User({
  5.   first_name: 'zhang',
  6.   last_name: 'san'
  7. })
  9. console.log(user.get_full_name())

运行：

  1. $ neon build
  2. $ node lib/index.js
  3. zhangsan

3.5.5 NAPI

NAPI 是 node@8 新添加的用于原生模块开发的接口，相较于以前的开发方式，NAPI 提供了稳定的 ABI 接口，消除了 Node.js 版本差异、引擎差异等编译后不兼容的问题。

目前 NAPI 还处于试验阶段，所以相关资料并不多，笔者写了一个 demo 放到了 GitHub 上，这里直接 clone 下来运行：

  1. $ git clone https://github.com/nswbmw/rust-napi-demo

主要文件代码如下：

src/lib.rs

  1. #[macro_use]
  2. extern crate napi;
  3. #[macro_use]
  4. extern crate napi_derive;
  6. use napi::{NapiEnv, NapiNumber, NapiResult};
  8. #[derive(NapiArgs)]
  9. struct Args<'a> {
  10.   n: NapiNumber<'a>
  11. }
  13. fn fibonacci<'a>(env: &'a NapiEnv, args: &Args<'a>) -> NapiResult<NapiNumber<'a>> {
  14.   let number = args.n.to_i32()?;
  15.   NapiNumber::from_i32(env, _fibonacci(number))
  16. }
  18. napi_callback!(export_fibonacci, fibonacci);
  20. fn _fibonacci(n: i32) -> i32 {
  21.   match n {
  22.     1 | 2 => 1,
  23.     _ => _fibonacci(n - 1) + _fibonacci(n - 2)
  24.   }
  25. }

index.js

  1. const rust = require('./build/Release/example.node')
  3. function fib (n) {
  4.   if (n === 1 || n === 2) {
  5.     return 1
  6.   }
  7.   return fib(n - 1) + fib(n - 2)
  8. }
  10. // js
  11. console.time('node')
  12. console.log(fib(40))
  13. console.timeEnd('node')
  15. // rust
  16. console.time('rust')
  17. console.log(rust.fibonacci(40))
  18. console.timeEnd('rust')

运行结果：

  1. $ npm start
  2. 102334155
  3. node: 1087.650ms
  4. 102334155
  5. rust: 268.395ms
  6. (node:33302) Warning: N-API is an experimental feature and could change at any time.

3.5.6 参考链接

上一节：3.4 Node@8

下一节：3.6 Event Loop