I have some function开发者_高级运维s which occasionally (not always) will receive a callback and run it. Is checking if the callback is defined/function a good style or is there a better way?
Example:
function save (callback){
.....do stuff......
if(typeof callback !== 'undefined'){
callback();
};
};
I personally prefer
typeof callback === 'function' && callback();
The typeof
command is dodgy however and should only be used for "undefined"
and "function"
The problems with the typeof !== undefined
is that the user might pass in a value that is defined and not a function
You can also do:
var noop = function(){}; // do nothing.
function save (callback){
callback = callback || noop;
.....do stuff......
};
It's specially useful if you happen to use the callback
in a few places.
Additionally if you are using jQuery
, you already have a function like that, it's called $.noop
Simply do
if (callback) callback();
I prefer to call the callback if supplied, no matter what type it is. Don't let it fail silently, so the implementor knows he passed in an incorrect argument and can fix it.
ECMAScript 6
// @param callback Default value is a noop fn.
const save = (callback = () => {}) => {
callback(); // Executes callback when specified otherwise does nothing
};
Rather than make the callback optional, just assign a default and call it no matter what
const identity = x =>
x
const save (..., callback = identity) {
// ...
return callback (...)
}
When used
save (...) // callback has no effect
save (..., console.log) // console.log is used as callback
Such a style is called continuation-passing style. Here's a real example, combinations
, that generates all possible combinations of an Array input
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' ]
// ]
Because combinations
is defined in continuation-passing style, the above call is effectively the same
combinations (['A', 'B', 'C'], console.log)
// [ []
// , [ 'C' ]
// , [ 'B' ]
// , [ 'B', 'C' ]
// , [ 'A' ]
// , [ 'A', 'C' ]
// , [ 'A', 'B' ]
// , [ 'A', 'B', 'C' ]
// ]
We can also pass a custom continuation that does something else with the result
console.log (combinations (['A', 'B', 'C'], combs => combs.length))
// 8
// (8 total combinations)
Continuation-passing style can be used with surprisingly elegant results
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, ...)
I got so tired of seeing that same snippet over and over I wrote this:
var cb = function(g) {
if (g) {
var args = Array.prototype.slice.call(arguments);
args.shift();
g.apply(null, args);
}
};
I've got hundred of functions doing things like
cb(callback, { error : null }, [0, 3, 5], true);
or whatever...
I'm skeptical of the whole "make sure it's function" strategy. The only legitimate values are a function or falsy. If someone passes in a non-zero number or a non-empty string, what are you going to do? How does ignoring the problem solve it?
A valid function is based on the Function prototype, use:
if (callback instanceof Function)
to be sure the callback is a function
If the criteria for running the callback is that whether its defined or not, then you're fine. Also, I suggest to check if its really a function in addition.
I have sinced moved to coffee-script and found default arguments is a nice way to solve this problem
doSomething = (arg1, arg2, callback = ()->)->
callback()
It can easilly be done with ArgueJS:
function save (){
arguments = __({callback: [Function]})
.....do stuff......
if(arguments.callback){
callback();
};
};
精彩评论