What's the best practice for function callback structure? [closed]

Question

Which function callback structure is the best to use in Javascript and why? I have seen these two options use quite a lot. Are there any more?

Option 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: ':-)'
});

Option 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

It depends on the environment, for node.js

I would personally recommend you stick to callback as the last parameter

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

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

Mainly because that's the coding style used in the node community. If you're not interacting with node.js at all then you should probably use the style most common to the environment you're interacting with.

If your environment mainly revolves around jQuery then I would just return a $.Deferred object from your doSomething function

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

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

Edit:

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

Answer 2

It doesn't really matter what you pick. I'd prefer B because I can add more error codes without changing the function definition.

You can also use the another pattern where your 'callback' is a hash of functions {error: function(){}, success: function(){}}. And this is extensible and quite common in JS libraries.