İsteğe bağlı geri aramalar için JavaScript stili

Ara sıra (her zaman değil) geri arama alacak ve çalıştıracak bazı işlevlerim var. Geri aramanın tanımlı olup olmadığını / çalışıp çalışmadığını kontrol etmek iyi bir stil mi yoksa daha iyi bir yol var mı?

Misal:

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

Şahsen tercih ederim

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

typeofKomut ancak tehlikeli ve sadece kullanılması gerektiğini "undefined"ve"function"

İle ilgili sorun typeof !== undefined, kullanıcının bir işlev değil , tanımlanmış bir değeri geçmesidir.

Ayrıca şunları da yapabilirsiniz:

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

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

callbackBirkaç yerde kullanıyorsanız özellikle yararlıdır .

Ek olarak eğer kullanıyorsanız jQuery, zaten böyle bir fonksiyona sahipsiniz, buna $ .noop denir

Basitçe yap

if (callback) callback();

Ne tür olursa olsun, sağlanırsa geri aramayı aramayı tercih ederim. Sessizce başarısız olmasına izin vermeyin, böylece uygulayıcı yanlış bir argümandan geçtiğini bilir ve düzeltebilir.

ECMAScript 6

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

Geri aramayı isteğe bağlı yapmak yerine, bir varsayılan atayın ve ne olursa olsun çağırın

const identity = x =>
  x

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

Kullanıldığında

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

Böyle bir stile devamlılık geçiş stili denir . İşte combinationsArray girdisinin tüm olası kombinasyonlarını oluşturan gerçek bir örnek

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

Çünkü combinationsdevamıdır geçen tarzda tanımlanmıştır, yukarıda belirtilen arama etkili bir şekilde aynıdır

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

Sonuçla başka bir şey yapan özel bir devamı da geçebiliriz

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

Devam eden stil, şaşırtıcı derecede zarif sonuçlarla kullanılabilir

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

Aynı pasajı tekrar tekrar görmekten o kadar yoruldum ki şunu yazdım:

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

Gibi şeyler yapan yüzlerce işleve sahibim

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

ya da her neyse...

"İşe yaradığından emin olun" stratejisine şüpheyle yaklaşıyorum. Tek meşru değerler bir işlev veya yanlıştır. Birisi sıfır olmayan bir sayı veya boş olmayan bir dizge girerse, ne yapacaksınız? Problemi görmezden gelmek onu nasıl çözer?

Geçerli bir işlev, İşlev prototipine dayanır, şunu kullanın:

if (callback instanceof Function)

geri aramanın bir işlev olduğundan emin olmak için

Geri aramayı çalıştırmanın ölçütü tanımlı olsun ya da olmasın, o zaman sorun yok. Ayrıca, ek olarak gerçekten bir işlev olup olmadığını kontrol etmenizi öneririm.

Kahve senaryosuna geçtim ve varsayılan argümanların bu sorunu çözmenin güzel bir yolu olduğunu öğrendim.

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

ArgueJS ile kolaylıkla yapılabilir :

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