Question

哪个函数回调结构最适合在Javascript中使用？为什么？我看到这两个选项使用了很多。还有吗？

选项A：

// DECLARATION
function funcA(required, success, error, options){

  // if there is an error in your function return 
  // and run error function
  if(errorHappens){ return error('an error') };

  // if no error happened: run the success function
  success('all good here is your var back', required);
}

。

// USAGE
funcA('this is required', function(result){

  // all good, do something with the result :)

},
function(error){

  // tell the user about the error
  alert('error happened')  
},{
  optionalThing: ':-)'
});

选项B：

// DECLARATION
function funcB(required, callback, options){

  // if an error happens run the single callback with
  // the err param populated and return
  if(errorHappens){ return callback('an error') };

  // if no error happened: run the callback with 'null'
  // as the error param.
  callback(null, 'this is a result');
}

// USAGE
funcB('this is required', function(err, result){
  if(err){ return alert('error happened') };

  // all good do something with the result :)

},{
  optionalThing: ':-)'
}

Answer 1

取决于环境，对于node.js

我个人建议你坚持回调作为最后一个参数

function doSomething(data, options, cb) {
  ...
  if (err) return cb(err);
  cb(null, result);
}

doSomething(data, { ... }, function (err, data) {
    if (err) throw err;
    ...
});

主要是因为这是节点社区中使用的编码风格。如果您根本没有与node.js进行交互，那么您应该使用与您正在交互的环境最常见的样式。

如果您的环境主要围绕jQuery，那么我只会从$.Deferred函数返回doSomething个对象

function doSomething(data, options) {
  return $.Deferred();
}

$.when(
  doSomething(data, { ... })
).then(
  function () { /* success */ },
  function () { /* error */ }
);

修改

function doSomething(data, options, cb) { if (typeof options === "function") { cb = options; options = null; } ... }

Answer 2

你选择什么并不重要。我更喜欢B，因为我可以在不改变函数定义的情况下添加更多错误代码。

您还可以使用另一种模式，其中“回调”是函数{error: function(){}, success: function(){}}的哈希值。这在JS库中是可扩展的并且很常见。

Answer 3

我更喜欢以下列形式传递对象文字：

var callback = {
    success : function(){},
    error : function(){},
    complete : function(){}
};

以这种方式使用它：

function(callback){
    try{
        /*...processing...*/
        if(success)
            typeof callback.success === 'function' && callback.success(result);
        else 
            throw new Error('unsuccesfull');
    }catch(err){
        typeof callback.error === 'function' && callback.error(err.message);
    }finally{
        typeof callback.complete === 'function' && callback.complete() || typeof callback === 'function' && callback();
    }
}

主要的优点是，通过这种方式，我可以为每个结果状态提供回调，但我也可以省略任何我想要的状态回调。我甚至可以传递一个函数（而不是一个对象），它将等同于complete回调。

Answer 4

都不是。

我更喜欢带有参数哈希的全功能版本，以及带有“常用”参数作为参数的快捷方法。

哪个最有意义取决于相关功能的使用模式。

函数回调结构的最佳实践是什么？

4 个答案: