Estilo JavaScript para devoluciones de llamada opcionales

Tengo algunas funciones que ocasionalmente (no siempre) recibirán una devolución de llamada y la ejecutarán. ¿Verificar si la devolución de llamada está definida / funciona es un buen estilo o hay una mejor manera?

Ejemplo:

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

Yo personalmente prefiero

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

El typeofcomando es sin embargo poco fiables y sólo debe utilizarse para "undefined"e"function"

El problema con typeof !== undefinedes que el usuario puede pasar un valor que está definido y no una función

También puedes hacer:

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

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

Es especialmente útil si usa el callbacken algunos lugares.

Además, si está utilizando jQuery, ya tiene una función como esa, se llama $ .noop

Simplemente haz

if (callback) callback();

Prefiero llamar a la devolución de llamada si se proporciona, sin importar de qué tipo sea. No permita que falle en silencio, para que el implementador sepa que pasó en un argumento incorrecto y pueda solucionarlo.

ECMAScript 6

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

En lugar de hacer que la devolución de llamada sea opcional, simplemente asigne un valor predeterminado y llámelo sin importar qué

const identity = x =>
  x

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

Cuando se utilizan

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

Este estilo se llama estilo de continuación-pase . Aquí hay un ejemplo real combinations, que genera todas las combinaciones posibles de una entrada 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' ]
// ]

Debido a que combinationsse define en estilo de paso de continuación, la llamada anterior es efectivamente la misma

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

También podemos pasar una continuación personalizada que hace algo más con el resultado.

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

El estilo de continuación de pases se puede utilizar con resultados sorprendentemente elegantes

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, ...)

Me cansé tanto de ver el mismo fragmento una y otra vez que escribí esto:

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

Tengo cientos de funciones que hacen cosas como

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

o lo que sea...

Soy escéptico de toda la estrategia de "asegúrese de que funcione". Los únicos valores legítimos son una función o una falsedad. Si alguien pasa un número distinto de cero o una cadena no vacía, ¿qué vas a hacer? ¿Cómo lo resuelve ignorar el problema?

Una función válida se basa en el prototipo de función, utilice:

if (callback instanceof Function)

para asegurarse de que la devolución de llamada sea una función

Si el criterio para ejecutar la devolución de llamada es que esté definido o no, entonces está bien. Además, sugiero verificar si realmente es una función adicional.

Me he movido a coffee-script y encontré que los argumentos predeterminados son una buena manera de resolver este problema

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

Se puede hacer fácilmente con ArgueJS :

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