Gaya JavaScript untuk callback opsional

Saya memiliki beberapa fungsi yang terkadang (tidak selalu) akan menerima panggilan balik dan menjalankannya. Apakah memeriksa apakah callback didefinisikan / berfungsi dengan gaya yang baik atau apakah ada cara yang lebih baik?

Contoh:

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

Saya pribadi lebih suka

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

Namun typeofperintahnya cerdik dan hanya boleh digunakan untuk "undefined"dan"function"

Masalah dengan yang typeof !== undefinedadalah bahwa pengguna mungkin mengirimkan nilai yang didefinisikan dan bukan fungsi

Anda juga bisa melakukan:

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

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

Ini sangat berguna jika Anda kebetulan menggunakannya callbackdi beberapa tempat.

Selain itu, jika Anda menggunakan jQuery, Anda sudah memiliki fungsi seperti itu, namanya $ .noop

Lakukan saja

if (callback) callback();

Saya lebih suka memanggil callback jika disediakan, apa pun jenisnya. Jangan biarkan gagal secara diam-diam, sehingga pelaksana tahu bahwa dia memberikan argumen yang salah dan dapat memperbaikinya.

ECMAScript 6

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

Daripada menjadikan panggilan balik opsional, tetapkan saja default dan panggil itu apa pun yang terjadi

const identity = x =>
  x

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

Saat digunakan

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

Gaya seperti itu disebut gaya penerusan-lanjutan . Berikut adalah contoh nyata combinations, yang menghasilkan semua kemungkinan kombinasi 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' ]
// ]

Karena combinationsdidefinisikan dalam gaya penerusan-penerusan, panggilan di atas secara efektif sama

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

Kami juga dapat meneruskan kelanjutan kustom yang melakukan hal lain dengan hasilnya

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

Gaya passing lanjutan dapat digunakan dengan hasil yang sangat elegan

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

Saya sangat lelah melihat cuplikan yang sama berulang kali saya menulis ini:

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

Saya memiliki ratusan fungsi yang melakukan hal-hal seperti

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

atau terserah...

Saya skeptis terhadap keseluruhan strategi "pastikan fungsinya". Satu-satunya nilai yang sah adalah fungsi atau falsy. Jika seseorang memasukkan angka bukan nol atau string tidak kosong, apa yang akan Anda lakukan? Bagaimana mengabaikan masalah menyelesaikannya?

Fungsi yang valid didasarkan pada prototipe Fungsi, gunakan:

if (callback instanceof Function)

untuk memastikan panggilan balik adalah sebuah fungsi

Jika kriteria untuk menjalankan callback adalah apakah itu ditentukan atau tidak, maka Anda baik-baik saja. Juga, saya sarankan untuk memeriksa apakah itu benar-benar fungsi tambahan.

Saya telah dengan tulus pindah ke skrip kopi dan menemukan argumen default adalah cara yang bagus untuk menyelesaikan masalah ini

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

Ini dapat dengan mudah dilakukan dengan ArgueJS :

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