Question

我有一些偶尔（并不总是）会收到回调并运行它的函数。检查回调是否定义/功能是一种好的风格还是有更好的方式？

示例：

function save (callback){
   .....do stuff......
   if(typeof callback !== 'undefined'){
     callback();
   };
};

Answer 1

我个人更喜欢

typeof callback === 'function' && callback();

typeof命令很狡猾，只能用于"undefined"和"function"

typeof !== undefined的问题是用户可能传入已定义的值且不是函数

Answer 2

你也可以这样做：

var noop = function(){}; // do nothing.

function save (callback){
   callback = callback || noop;
   .....do stuff......
};

如果您碰巧在一些地方使用callback，这将特别有用。

此外，如果您使用的是jQuery，那么您已经拥有了这样的功能，它被称为$.noop

Answer 3

简单地做

if (callback) callback();

如果提供回调，我更喜欢调用回调，无论它是什么类型。不要让它无声地失败，因此实现者知道他传递了一个不正确的参数并且可以修复它。

Answer 4

ECMAScript 6

// @param callback Default value is a noop fn.
function save(callback = ()=>{}) {
   // do stuff...
   callback();
}

Answer 5

我厌倦了一遍又一遍地看到同样的片段我写道：

  var cb = function(g) {
    if (g) {
      var args = Array.prototype.slice.call(arguments); 
      args.shift(); 
      g.apply(null, args); 
    }
  };

我有数百个函数在做像

这样的事情

  cb(callback, { error : null }, [0, 3, 5], true);

或其他......

我对整个“确定它的功能”策略持怀疑态度。唯一合法的价值观是功能或假。如果有人传入非零数字或非空字符串，您打算做什么？忽视这个问题怎么解决呢？

Answer 6

有效函数基于Function原型，使用：

if (callback instanceof Function)

确保回调是一个函数

Answer 7

与其将回调设为可选，不如分配一个默认值并在任何情况下调用它

const identity = x =>
  x

const save (..., callback = identity) {
  // ...
  return callback (...)
}

使用时

save (...)              // callback has no effect
save (..., console.log) // console.log is used as callback

这种样式称为continuation-passing style。这是一个真实的示例combinations，它生成Array输入的所有可能组合

const identity = x =>
  x

const None =
  Symbol ()

const combinations = ([ x = None, ...rest ], callback = identity) =>
  x === None
    ? callback ([[]])
    : combinations
        ( rest
        , combs =>
            callback (combs .concat (combs .map (c => [ x, ...c ])))
        )

console.log (combinations (['A', 'B', 'C']))
// [ []
// , [ 'C' ]
// , [ 'B' ]
// , [ 'B', 'C' ]
// , [ 'A' ]
// , [ 'A', 'C' ]
// , [ 'A', 'B' ]
// , [ 'A', 'B', 'C' ]
// ]

由于combinations以连续传递样式定义，因此上述调用实际上是相同的

combinations (['A', 'B', 'C'], console.log)
// [ []
// , [ 'C' ]
// , [ 'B' ]
// , [ 'B', 'C' ]
// , [ 'A' ]
// , [ 'A', 'C' ]
// , [ 'A', 'B' ]
// , [ 'A', 'B', 'C' ]
// ]

我们还可以传递自定义延续，对结果进行其他操作

console.log (combinations (['A', 'B', 'C'], combs => combs.length))
// 8
// (8 total combinations)

可以使用连续传递样式，效果出奇的优雅

const first = (x, y) =>
  x

const fibonacci = (n, callback = first) =>
  n === 0
    ? callback (0, 1)
    : fibonacci
        ( n - 1
        , (a, b) => callback (b, a + b)
        )
        
console.log (fibonacci (10)) // 55
// 55 is the 10th fibonacci number
// (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...)

Answer 8

如果运行回调的标准是它的定义与否，那么你没事。另外，我建议检查它是否真的是一个功能。

Answer 9

我已经转移到咖啡脚本并发现默认参数是解决此问题的好方法

doSomething = (arg1, arg2, callback = ()->)->
    callback()

Answer 10

可以使用ArgueJS轻松完成：

function save (){
  arguments = __({callback: [Function]})
.....do stuff......
  if(arguments.callback){
    callback();
  };
};

用于可选回调的JavaScript样式

10 个答案:

ECMAScript 6