Stile JavaScript per callback opzionali

Ho alcune funzioni che occasionalmente (non sempre) riceveranno una richiamata e la eseguiranno. Controllare se il callback è definito / funzione è uno stile buono o c'è un modo migliore?

Esempio:

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

Personalmente preferisco

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

Il typeofcomando è tuttavia rischioso e dovrebbe essere usato solo per "undefined"e"function"

Il problema con typeof !== undefinedè che l'utente potrebbe passare un valore definito e non una funzione

Puoi anche fare:

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

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

È particolarmente utile se ti capita di utilizzare callbackin pochi posti.

Inoltre, se stai usando jQuery, hai già una funzione del genere, si chiama $ .noop

Fallo semplicemente

if (callback) callback();

Preferisco richiamare la richiamata se fornita, indipendentemente dal tipo. Non lasciare che fallisca silenziosamente, così l'implementatore sa di aver passato un argomento errato e può aggiustarlo.

ECMAScript 6

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

Piuttosto che rendere facoltativa la richiamata, assegna semplicemente un valore predefinito e chiamalo qualunque cosa accada

const identity = x =>
  x

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

Quando viene utilizzato

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

Tale stile è chiamato stile di passaggio di continuazione . Ecco un esempio reale combinations, che genera tutte le possibili combinazioni di un input 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' ]
// ]

Poiché combinationsè definito nello stile del passaggio di continuazione, la chiamata di cui sopra è effettivamente la stessa

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

Possiamo anche passare una continuazione personalizzata che fa qualcos'altro con il risultato

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

Lo stile di passaggio continuo può essere utilizzato con risultati sorprendentemente eleganti

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

Mi sono stancato di vedere lo stesso frammento più e più volte ho scritto questo:

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

Ho centinaia di funzioni che fanno cose come

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

o qualunque cosa ...

Sono scettico sull'intera strategia "assicurati che funzioni". Gli unici valori legittimi sono una funzione o il falso. Se qualcuno passa un numero diverso da zero o una stringa non vuota, cosa farai? Come risolverlo ignorando il problema?

Una funzione valida si basa sul prototipo della funzione, utilizzare:

if (callback instanceof Function)

per essere sicuri che il callback sia una funzione

Se il criterio per eseguire la richiamata è che sia definito o meno, allora stai bene. Inoltre, suggerisco di verificare se è davvero una funzione aggiuntiva.

Sono passato a coffee-script e ho scoperto che gli argomenti predefiniti sono un bel modo per risolvere questo problema

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

Può essere fatto facilmente con ArgueJS :

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