JavaScript-Stil für optionale Rückrufe

Ich habe einige Funktionen, die gelegentlich (nicht immer) einen Rückruf erhalten und ausführen. Ist die Überprüfung, ob der Rückruf definiert ist / funktioniert, ein guter Stil oder gibt es einen besseren Weg?

Beispiel:

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

Ich persönlich bevorzuge

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

Der typeofBefehl ist jedoch zwielichtig und sollte nur für "undefined"und verwendet werden"function"

Das Problem dabei typeof !== undefinedist, dass der Benutzer möglicherweise einen definierten Wert und keine Funktion übergibt

Sie können auch tun:

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

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

Es ist besonders nützlich, wenn Sie das callbackan einigen Stellen verwenden.

Wenn Sie verwenden jQuery, haben Sie bereits eine solche Funktion namens $ .noop

Einfach machen

if (callback) callback();

Ich rufe den Rückruf lieber an, wenn er geliefert wird, egal um welchen Typ es sich handelt. Lassen Sie es nicht stillschweigend scheitern, damit der Implementierer weiß, dass er ein falsches Argument übergeben hat und es beheben kann.

ECMAScript 6

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

Anstatt den Rückruf optional zu machen, weisen Sie einfach einen Standard zu und rufen Sie ihn auf, egal was passiert

const identity = x =>
  x

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

Wenn benutzt

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

Ein solcher Stil wird als Continuation-Passing-Stil bezeichnet . Hier ist ein reales Beispiel, combinationsdas alle möglichen Kombinationen einer Array-Eingabe generiert

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' ]
// ]

Da combinationsder obige Aufruf im Continuation-Passing-Stil definiert ist, ist er praktisch derselbe

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

Wir können auch eine benutzerdefinierte Fortsetzung übergeben, die etwas anderes mit dem Ergebnis macht

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

Der Continuation-Passing-Stil kann mit überraschend eleganten Ergebnissen verwendet werden

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

Ich war es so leid, immer wieder denselben Ausschnitt zu sehen, dass ich Folgendes schrieb:

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

Ich habe Hunderte von Funktionen, die Dinge wie tun

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

oder Wasauchimmer...

Ich bin skeptisch gegenüber der gesamten Strategie "Stellen Sie sicher, dass sie funktioniert". Die einzigen legitimen Werte sind eine Funktion oder eine Falschheit. Was tun Sie, wenn jemand eine Zahl ungleich Null oder eine nicht leere Zeichenfolge übergibt? Wie löst das Ignorieren des Problems das Problem?

Eine gültige Funktion basiert auf dem Funktionsprototyp. Verwenden Sie:

if (callback instanceof Function)

um sicherzugehen, dass der Rückruf eine Funktion ist

Wenn das Kriterium für die Ausführung des Rückrufs lautet, ob er definiert ist oder nicht, ist alles in Ordnung. Außerdem schlage ich vor zu prüfen, ob es wirklich eine Funktion zusätzlich ist.

Ich bin zum Kaffee-Skript übergegangen und habe festgestellt, dass Standardargumente ein guter Weg sind, um dieses Problem zu lösen

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

Mit ArgueJS geht das ganz einfach :

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