Стиль JavaScript для дополнительных обратных вызовов

Question

У меня есть некоторые функции, которые иногда (не всегда) получают обратный вызов и запускают его. Является ли проверка, определен ли обратный вызов / функция, является хорошим стилем или есть лучший способ?

Пример:

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

Answer 1

лично я предпочитаю

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

Команда typeof является хитрой, однако ее следует использовать только для "undefined" и "function"

Проблема с typeof !== undefined состоит в том, что пользователь может передать определенное значение, а не является функцией

Answer 2

Вы также можете сделать:

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

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

Это особенно полезно, если вы используете callback в нескольких местах.

Кроме того, если вы используете jQuery, у вас уже есть такая функция, она называется $. Noop

Answer 3

Просто сделай

if (callback) callback();

Я предпочитаю вызывать обратный вызов, если он указан, независимо от его типа. Не позволяйте, чтобы это молча провалилось, поэтому разработчик знает, что он передал неверный аргумент, и может это исправить.

Answer 4

ECMAScript 6

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

Answer 5

Вместо того, чтобы сделать обратный вызов необязательным, просто назначьте значение по умолчанию и назовите его независимо от того, что

const identity = x =>
  x

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

При использовании

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

Такой стиль называется продолжение-стиль прохождения .Вот реальный пример, combinations, который генерирует все возможные комбинации ввода массива

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

Поскольку combinations определен в стиле передачи продолжения, вышеприведенный вызов по сути тот же

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

Мы также можем передать пользовательское продолжениечто-то еще с результатом

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

Стиль прохождения продолжения можно использовать с удивительно элегантными результатами

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

Answer 6

Действительная функция основана на прототипе функции, используйте:

if (callback instanceof Function)

чтобы быть уверенным, что обратный вызов является функцией

Answer 7

Я так устал видеть один и тот же фрагмент снова и снова, я написал это:

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

У меня есть сотни функций, выполняющих такие вещи, как

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

или что-то еще ...

Я скептически отношусь ко всей стратегии "убедитесь, что она функционирует". Единственными законными значениями являются функция или ложь. Если кто-то передает ненулевое число или непустую строку, что вы собираетесь делать? Как игнорирование проблемы решает ее?

Answer 8

Это можно легко сделать с помощью ArgueJS :

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

Answer 9

Я перешел на кофе-скрипт и нашел аргументы по умолчанию - хороший способ решить эту проблему

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

Answer 10

Если критерии для выполнения обратного вызова таковы, определен он или нет, то все в порядке.Кроме того, я предлагаю проверить, действительно ли это функция в дополнение.