Стиль JavaScript для додаткових зворотних викликів

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

Приклад:

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

Я особисто віддаю перевагу

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

Однак typeofкоманда хитра, і її слід використовувати лише для "undefined"та"function"

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

Ви також можете зробити:

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

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

Це особливо корисно, якщо ви випадково користуєтесь ними callbackв кількох місцях.

Крім того, якщо ви використовуєте jQuery, у вас вже є така функція, яка називається $ .noop

Просто зробіть

if (callback) callback();

Я вважаю за краще зателефонувати за зворотним викликом, якщо він наданий, незалежно від того, якого типу. Не дозволяйте йому мовчки провалюватися, тому реалізатор знає, що він передав неправильний аргумент, і може це виправити.

ECMAScript 6

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

Замість того, щоб зробити зворотний виклик необов’язковим, просто призначте за замовчуванням і зателефонуйте йому, незважаючи ні на що

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

Мені так набридло бачити той самий фрагмент знову і знову, я написав це:

  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);

або що завгодно ...

Я скептично налаштований на всю стратегію "переконайтесь, що це функція". Єдині законні значення - це функція або хибність. Якщо хтось передає нульове число або не порожню рядок, що ви збираєтеся робити? Як ігнорування проблеми вирішує її?

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

if (callback instanceof Function)

щоб переконатися, що зворотний дзвінок є функцією

Якщо критерієм запуску зворотного виклику є той, визначений він чи ні, то з вами все гаразд. Крім того, я пропоную перевірити, чи дійсно це функція додатково.

Я перейшов до сценарію кави і знайшов аргументи за замовчуванням - хороший спосіб вирішити цю проблему

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

Це можна легко зробити за допомогою ArgueJS :

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