Kiểu JavaScript cho các lệnh gọi lại tùy chọn

Tôi có một số chức năng thỉnh thoảng (không phải lúc nào) sẽ nhận được một cuộc gọi lại và chạy nó. Việc kiểm tra xem lệnh gọi lại có được xác định / hoạt động hay không hay có cách nào tốt hơn không?

Thí dụ:

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

Cá nhân tôi thích

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

Các typeoflệnh là tuy nhiên tinh ranh và chỉ nên được sử dụng cho "undefined"và"function"

Các vấn đề với hàm typeof !== undefinedlà người dùng có thể chuyển vào một giá trị được xác định và không phải là một hàm

Bạn cũng có thể làm:

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

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

Nó đặc biệt hữu ích nếu bạn tình cờ sử dụng callbackở một vài nơi.

Ngoài ra, nếu bạn đang sử dụng jQuery, bạn đã có một chức năng như vậy, nó được gọi là $ .noop

Đơn giản là làm

if (callback) callback();

Tôi muốn gọi lại cuộc gọi lại nếu được cung cấp, bất kể đó là loại nào. Đừng để nó âm thầm thất bại, để người triển khai biết mình đã chuyển đối số sai và có thể sửa nó.

ECMAScript 6

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

Thay vì đặt lệnh gọi lại là tùy chọn, chỉ cần gán mặc định và gọi nó bất kể điều gì

const identity = x =>
  x

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

Khi đã sử dụng

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

Một phong cách như vậy được gọi là phong cách tiếp diễn . Đây là một ví dụ thực tế, combinationstạo ra tất cả các kết hợp có thể có của đầu vào Mảng

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

Bởi vì combinationsđược định nghĩa theo kiểu truyền tiếp tục, lệnh gọi trên có hiệu quả giống nhau

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

Chúng tôi cũng có thể chuyển một phần tiếp theo tùy chỉnh để thực hiện điều gì đó khác với kết quả

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

Phong cách truyền tiếp tục có thể được sử dụng với kết quả trang nhã đáng ngạc nhiên

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

Tôi đã quá mệt mỏi khi xem đi xem lại cùng một đoạn mã, tôi đã viết thế này:

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

Tôi có hàng trăm chức năng làm những việc như

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

hay bất cứ cái gì...

Tôi hoài nghi về toàn bộ chiến lược "đảm bảo rằng nó hoạt động". Các giá trị hợp pháp duy nhất là một hàm hoặc sai lệch. Nếu ai đó chuyển đến một số khác 0 hoặc một chuỗi không rỗng, bạn sẽ làm gì? Làm thế nào để bỏ qua vấn đề giải quyết nó?

Một hàm hợp lệ dựa trên nguyên mẫu Hàm, hãy sử dụng:

if (callback instanceof Function)

để đảm bảo gọi lại là một hàm

Nếu tiêu chí để chạy lệnh gọi lại là nó có được xác định hay không, thì bạn vẫn ổn. Ngoài ra, tôi khuyên bạn nên kiểm tra xem nó có thực sự là một chức năng bổ sung hay không.

Tôi đã chuyển sang coffee-script và thấy các đối số mặc định là một cách hay để giải quyết vấn đề này

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

Nó có thể được thực hiện một cách dễ dàng với ArgueJS :

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