Question

我正在尝试提出一种处理NodeJS中由于性能影响而不使用try catch的异常的一般（固定的）方式。我还想远离像流线这样的库，试图让异步代码看起来像同步代码。

似乎Domains很适合这个法案，但我想就我建议使用它们的方式征求意见/建议。这种方法存在重大问题吗？

我打算让我的大多数异步函数都遵循以下domainAware函数的模式：

function errorinAsync(options, callback){
    options = options || {};
    setTimeout(function(){
        return callback(new Error("This should be caught"));
    },1000);

}
function domainAware(options, callback){
    if(domain.active){
        d = domain.active;
    }else{
        d = domain.create();
        d.on('error', function(err){
            return callback(err);
        });
    }

    d.run(function(){
        //Some Synchronous code that might throw an exception;
        var a = {b: 1, c: 2};
        var thing = JSON.stringify(a);
        errorinAsync(null,d.intercept(function(err) {
            return callback(null);
        }));
    });
}

我想要做的是避免在异步函数中抛出错误。这主要是针对我没有任何我想要处理的特定异常的情况，但我想确保异常不会“丢失”。

我可以使用域上下文来调用它：

var d = domain.create();
d.on('error', function(er) {
  console.error('Caught error!', er);
});
d.run(function() {
    domainAware(null, d.intercept(function(err) {
        console.log("all Done");
    }));
});

或者没有一个：

domainAware(null, function(err){
    if(err){
        return console.log("Caught Error from Callback" + err);
    }
    console.log("all Done");
});

这个人为的例子运作良好，但是具有许多功能的更复杂场景呢。

更新：＃1

使用try catch的等效函数可能是：

function noHandling(callback){
    var a = {b: 1, c: 2};
    var thing = JSON.stringify(a);
    errorinAsync(null,function(err) {
        if(err) return callback(err);
        return callback(null);
    });
}

function notDomainAware(options, callback){
    try{
        noHandling(callback);
    }catch(err){
        callback(err);
    }
}

我将对这两种方法进行一些性能测试，看看是否存在差异。

除了性能之外，使用基于域的方法还有其他问题吗？域感知功能的修订版本可能如下所示。

function domainAware(options, callback){
    var d = domain.active || domain.create().on('error', function(err){ return callback(err); });

    d.run(function(){
        //Some Synchronous code that might throw an exception;
        var a = {b: 1, c: 2};
        var thing = JSON.stringify(a);
        errorinAsync(null,d.intercept(function(err) {
            return callback(null);
        }));
    });
}

我喜欢基于域的版本的简单性，但是它或多或少相同？当然你需要记住使用d.intercept或检查任何回调的错误，但我可以处理。

Answer 1

的更新 的

我已经做了更多的工作，发现了一种使用域编写异步函数的好方法，这些域消除了大多数异常处理样板，并且在某些情况下比try catch异常处理表现更好：

http://www.lighthouselogic.com/using-a-new-domain-for-each-async-function-in-node/

这取代了以下帖子中的大部分内容。实际上我在下面提出的函数useExistingDomainifAvailable有副作用，我在编写这个原始答案时没有考虑过。主要的一点是错误处理总是通过短路回到域异常处理程序而不是通过回调链。

的更新 的

所以，我做了一些性能测试，发现域版本实际上与在try catch中包装函数体大致相同：

我的所有测试都使用了以下两个函数：

function doSomethingAsync(options, callback){ options = options || {}; setTimeout(function(){ return callback(null); },1); } function callThroughDomain(fn, callback) { var d = domain.create(); d.on('error', function(er) { console.error('Caught error!', er); }); d.run(function() { fn(1000000, d.intercept(callback)); }); }

我开始使用控件：

function tryCatchCallback(j, callback) { try{ var s = 0; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; doSomethingAsync(null, function(err){ //Just like domain.intercept, exceptions in the callback are handled try{ if(err) return callback(err); callback(s); }catch(ex){ callback(ex); } }); } catch(ex) { callback(ex); } }

测试的结果是：

callThroughDomain(tryCatchCallback, function(){ deferred.resolve(); });

然后我尝试使用预先声明的域名：

function useExistingDomainifAvailable(j, callback) { var d = domain.active || domain.create().on('error', function(err){ return callback(err); }); d.run(function(){ var s = 0; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; doSomethingAsync(null, d.intercept(function(err){ callback(s); })); }); } callThroughDomain(useExistingDomainifAvailable, function(){ deferred.resolve(); });

然后我尝试了外部try catch
调用的函数的内容
function tryCatchOuter(j, callback) { try{ outer(1000000, callback); }catch(e){ console.log(e); } } function outer(j, callback) { var s = 0; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; doSomethingAsync(null, function(err){ //Again catching errors from callback try{ if(err) return callback(err); callback(s); }catch(ex){ callback(ex) } }); } callThroughDomain(tryCatchOuter, function(){ deferred.resolve(); });

我的benchmark.js测试结果如下：

控制x 42.12 ops / sec±0.83％（38次运行采样）
useExistingDomainifAvailable x 41.98 ops / sec±6.67％（44次采样）
tryCatchOuter x 93.23 ops / sec±2.07％（66次运行采样）
最快的是tryCatchOuter

显示tryCatchOuter方案的显着性能增益。

最后比较尝试使用外部函数体的域

function domainWithOuter(j, callback) { var d = domain.active || domain.create().on('error', function(err){ return callback(err); }); d.run(function(){ outerNoHandler(j,callback); }); } function outerNoHandler(j, callback) { var s = 0; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; for (var i = 0; i < j; i++) s = i; doSomethingAsync(null, function(err){ //Don't need try catch here //Exceptions managed by domain if(err) return callback(err); callback(s); }); }

控制x 42.75 ops / sec±1.06％（采样39次）
useExistingDomainifAvailable x 42.86 ops / sec±6.81％（38次运行采样）
tryCatchOuter x 95.86 ops / sec±2.35％（68次采样）
domainWithOuter x 94.65 ops / sec±1.91％（67次运行采样）
最快的是tryCatchOuter，domainWithOuter

所以基本上使用域与在这种情况下在性能方面使用try catch相同，语法有些不同。

我想因为domain.run和doman.intercept在封面下使用try catch，所以需要以类似的方式使用它们以及相同的性能警告。

在NodeJS中编写域感知功能

1 个答案: