首頁 > web前端 > js教程 > 主體

Node.js編寫元件的三種實作方式_node.js

WBOY
發布: 2016-05-16 15:13:44
原創
1646 人瀏覽過

首先介紹使用v8 API跟使用swig框架的不同:

(1)v8 API方式為官方提供的原生方法,功能強大而完善,缺點是需要熟悉v8 API,編寫起來比較麻煩,是js強相關的,不容易支援其它腳本語言。

(2)swig為第三方支持,一個強大的元件開發工具,支援為python、lua、js等多種常見腳本語言產生C++元件包裝程式碼,swig使用者只需要編寫C++程式碼和swig設定文件即可開發各種腳本語言的C++元件,不需要了解各種腳本語言的元件開發框架,缺點是不支援javascript的回調,文件和demo程式碼不完善,使用者不多。

一、純JS實作Node.js元件
(1)到helloworld目錄下執行npm init 初始化package.json,各種選項先不管,預設即可。

(2)元件的實作index.js,例如:

module.exports.Hello = function(name) {
    console.log('Hello ' + name);
}
登入後複製

(3)在外層目錄執行:npm install ./helloworld,helloworld於是安裝到了node_modules目錄中。
(4)編寫元件使用程式碼:

var m = require('helloworld');
m.Hello('zhangsan');
//输出: Hello zhangsan
登入後複製

二、 使用v8 API實作JS元件-同步模式
 (1)寫binding.gyp, eg:

{
 "targets": [
  {
   "target_name": "hello",
   "sources": [ "hello.cpp" ]
  }
 ]
}
登入後複製

(2)編寫元件的實作hello.cpp,eg:

#include <node.h>

namespace cpphello {
  using v8::FunctionCallbackInfo;
  using v8::Isolate;
  using v8::Local;
  using v8::Object;
  using v8::String;
  using v8::Value;

  void Foo(const FunctionCallbackInfo<Value>& args) {
    Isolate* isolate = args.GetIsolate();
    args.GetReturnValue().Set(String::NewFromUtf8(isolate, "Hello World"));
  }

  void Init(Local<Object> exports) {
    NODE_SET_METHOD(exports, "foo", Foo);
  }

  NODE_MODULE(cpphello, Init)
}

登入後複製

(3)編譯組件

node-gyp configure
node-gyp build
./build/Release/目录下会生成hello.node模块。
登入後複製

 (4)寫測試js程式碼

const m = require('./build/Release/hello')
console.log(m.foo()); //输出 Hello World
登入後複製

 (5)增加package.json 用於安裝 eg:

{                                                                                                         
  "name": "hello",
  "version": "1.0.0",
  "description": "", 
  "main": "index.js",
  "scripts": {
    "test": "node test.js"
  }, 
  "author": "", 
  "license": "ISC"
}
登入後複製

(5)安裝組件到node_modules

進入到元件目錄的上級目錄,執行:npm install ./helloc //註:helloc為元件目錄
會在目前目錄下的node_modules目錄下安裝hello模組,測試程式碼這樣子寫:

var m = require('hello');
console.log(m.foo());  
登入後複製

三、 使用v8 API實作JS元件-非同步模式
上面描述的是同步元件,foo()是一個同步函數,也就是foo()函數的呼叫者需要等待foo()函數執行完才能往下走,當foo()函數是一個有IO耗時操作的函數時,非同步的foo()函數可以減少阻塞等待,提高整體效能。

非同步元件的實作只需要關注libuv的uv_queue_work API,元件實作時,除了主體程式碼hello.cpp和元件使用者程式碼,其它部分都與上面三的demo一致。

hello.cpp:

/*
* Node.js cpp Addons demo: async call and call back.
* gcc 4.8.2
* author:cswuyg
* Date:2016.02.22
* */
#include <iostream>
#include <node.h>
#include <uv.h> 
#include <sstream>
#include <unistd.h>
#include <pthread.h>

namespace cpphello {
  using v8::FunctionCallbackInfo;
  using v8::Function;
  using v8::Isolate;
  using v8::Local;
  using v8::Object;
  using v8::Value;
  using v8::Exception;
  using v8::Persistent;
  using v8::HandleScope;
  using v8::Integer;
  using v8::String;

  // async task
  struct MyTask{
    uv_work_t work;
    int a{0};
    int b{0};
    int output{0};
    unsigned long long work_tid{0};
    unsigned long long main_tid{0};
    Persistent<Function> callback;
  };

  // async function
  void query_async(uv_work_t* work) {
    MyTask* task = (MyTask*)work->data;
    task->output = task->a + task->b;
    task->work_tid = pthread_self();
    usleep(1000 * 1000 * 1); // 1 second
  }

  // async complete callback
  void query_finish(uv_work_t* work, int status) {
    Isolate* isolate = Isolate::GetCurrent();
    HandleScope handle_scope(isolate);
    MyTask* task = (MyTask*)work->data;
    const unsigned int argc = 3;
    std::stringstream stream;
    stream << task->main_tid;
    std::string main_tid_s{stream.str()};
    stream.str("");
    stream << task->work_tid;
    std::string work_tid_s{stream.str()};
    
    Local<Value> argv[argc] = {
      Integer::New(isolate, task->output), 
      String::NewFromUtf8(isolate, main_tid_s.c_str()),
      String::NewFromUtf8(isolate, work_tid_s.c_str())
    };
    Local<Function>::New(isolate, task->callback)->Call(isolate->GetCurrentContext()->Global(), argc, argv);
    task->callback.Reset();
    delete task;
  }

  // async main
  void async_foo(const FunctionCallbackInfo<Value>& args) {
    Isolate* isolate = args.GetIsolate();
    HandleScope handle_scope(isolate);
    if (args.Length() != 3) {
      isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate, "arguments num : 3")));
      return;
    } 
    if (!args[0]->IsNumber() || !args[1]->IsNumber() || !args[2]->IsFunction()) {
      isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate, "arguments error")));
      return;
    }
    MyTask* my_task = new MyTask;
    my_task->a = args[0]->ToInteger()->Value();
    my_task->b = args[1]->ToInteger()->Value();
    my_task->callback.Reset(isolate, Local<Function>::Cast(args[2]));
    my_task->work.data = my_task;
    my_task->main_tid = pthread_self();
    uv_loop_t *loop = uv_default_loop();
    uv_queue_work(loop, &my_task->work, query_async, query_finish); 
  }

  void Init(Local<Object> exports) {
    NODE_SET_METHOD(exports, "foo", async_foo);
  }

  NODE_MODULE(cpphello, Init)
}

登入後複製

非同步的思路很簡單,實作一個工作函數、一個完成函數、一個承載資料跨執行緒傳輸的結構體,呼叫uv_queue_work即可。困難點是對v8 資料結構、API的熟悉。

test.js

// test helloUV module
'use strict';
const m = require('helloUV')

m.foo(1, 2, (a, b, c)=>{
  console.log('finish job:' + a);
  console.log('main thread:' + b);
  console.log('work thread:' + c);
});
/*
output:
finish job:3
main thread:139660941432640
work thread:139660876334848
*/

登入後複製

四、swig-javascript 實作Node.js元件
利用swig框架編寫Node.js元件

(1)寫出好元件的實作:*.h和*.cpp

eg:

namespace a {
  class A{
  public:
    int add(int a, int y);
  };
  int add(int x, int y);
}
登入後複製

(2)寫*.i,用於產生swig的包裝cpp檔
eg:

/* File : IExport.i */
%module my_mod 
%include "typemaps.i"
%include "std_string.i"
%include "std_vector.i"
%{
#include "export.h"
%}
 
%apply int *OUTPUT { int *result, int* xx};
%apply std::string *OUTPUT { std::string* result, std::string* yy };
%apply std::string &OUTPUT { std::string& result };                                                                                
 
%include "export.h"
namespace std {
  %template(vectori) vector<int>;
  %template(vectorstr) vector<std::string>;
};
登入後複製

上面的%apply表示程式碼中的int* result、int* xx、std::string* result、std::string* yy、std::string& result是輸出描述,這是typemap,是一種替換。
C++函數參數中的指針參數,如果是返回值的(透過*.i檔案中的OUTPUT指定),swig都會把他們處理為JS函數的返回值,如果有多個指針,則JS函數的返回值是list。
%template(vectori) vector 則表示為JS定義了一個型別vectori,這一般是C++函式用到vector 作為參數或傳回值,在寫js程式碼時,需要用到它。
(3)寫binding.gyp,用於使用node-gyp編譯
(4)產生warpper cpp檔 產生時注意v8版本訊息,eg:swig -javascript -node -c++ -DV8_VERSION=0x040599 example.i
(5)編譯&測試
困難在於stl類型、自訂類型的使用,這方面官方文件太少。
swig - javascript對std::vector、std::string、的封裝使用請參考:我的練習,主要關注*.i檔案的實作。
五、其它
使用v8 API實作Node.js元件時,可以發現跟實作Lua元件的相似之處,Lua有狀態機,Node有Isolate。

Node實作物件導出時,需要實作一個建構函數,並為它增加“成員函數”,最後把建構子匯出為類別名稱。 Lua實作物件導出時,也需要實作一個建立物件的工廠函數,也需要把「成員函數」加到table裡。最後把工廠函數導出。

Node的js腳本有new關鍵字,Lua沒有,所以Lua對外只提供物件工廠用來建立對象,而Node可以提供物件工廠或類別封裝。

以上就是本文的全部內容,希望對大家的學習有所幫助。

來源:php.cn
本網站聲明
本文內容由網友自願投稿,版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容,請聯絡admin@php.cn
最新問題
熱門教學
更多>
最新下載
更多>
網站特效
網站源碼
網站素材
前端模板
關於我們 免責聲明 Sitemap
PHP中文網:公益線上PHP培訓,幫助PHP學習者快速成長!