Is is bad practice to pass an empty callback in Javascript?

Question

I have a long running function that I don't really care about handling properly. Is it bad practice to just hand it off to the event loop along with an empty callback and move on. Something like this:

var takeSomeTime = function(callback) {

  var count = 0,
      max = 1000,
      interval;

  interval = setInterval(function() {
    count++;
    if (count === max) {
      interval.clearInterval();
      return callback();
    }
  }, 1000);
};

var go = function(callback) {

  // do some stuff
  takeSomeTime(function(err) {
      if (err) {
          console.error(err)
      }
      // take all the time you need
      // I'm moving on to to do other things.
  });

  return callback();

};

go(function(){ 
  // all done... 
});

If you don't pass a function to `go()` then `return callback()` will fail with an error stating that `callback is not a function` — Scott Marcus, Jun 16 '17 at 21:58

score 1 · Answer 1 · answered Jun 16 '17 at 23:46

I don't know how your question is related to memory leaks, but one could certainly think of useful applications of passing empty function around in general. You basically could pass an empty function to third party code, that expects a function and doesn't check if it actually got one. Just like in your example, or this small logging library:

// Javascript enum pattern, snatched from TypeScript
var LogLevel;
(function (LogLevel) {
    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
    LogLevel[LogLevel["WARN"] = 1] = "WARN";
    LogLevel[LogLevel["ERROR"] = 2] = "ERROR";
    LogLevel[LogLevel["FATAL"] = 3] = "FATAL";
})(LogLevel || (LogLevel = {}));
// end enum pattern

var noLog = function() {}; // The empty callback

function getLogger(level) {
    var result = {
        debug: noLog,
        warn: noLog,
        error: noLog
    };

    switch(level) {
        case LogLevel.DEBUG:
            result.debug = console.debug.bind(console);
        case LogLevel.WARN:
            result.warn = console.warn.bind(console);
        case LogLevel.ERROR:
            result.error = console.error.bind(console);
    }
    return result;
}

var log1 = LogFactory.getLogger(LogLevel.DEBUG);
var log2 = LogFactory.getLogger(LogLevel.ERROR);

log1.debug('debug test');// calls console.debug and actually displays the
    // the correct place in the code from where it was called.

log2.debug('debug test');// calls noLog
log2.error('error test');// calls console.error

You basically return the empty function noLog back to the consumer of our library in order to disable logging for a particular log level, yet it can be called with any number of arguments without raising errors.

Is is bad practice to pass an empty callback in Javascript?

1 Answers1