Bu JavaScript kalıbı nedir ve neden kullanılır?

THREE.js üzerinde çalışıyorum ve işlevlerin şu şekilde tanımlandığı bir model fark ettim:

var foo = ( function () {
    var bar = new Bar();

    return function ( ) {
        //actual logic using bar from above.
        //return result;
    };
}());

(Örnek burada raycast yöntemine bakın ).

Normal Böyle bir yöntemin varyasyon şu şekilde görünecektir:

var foo = function () {
    var bar = new Bar();

    //actual logic.
    //return result;
};

İlk versiyonu normal varyasyonla karşılaştırdığımızda, ilk versiyon farklı görünüyor:

1. Kendi kendine çalışan bir işlevin sonucunu atar.
2. Bu işlev içinde yerel bir değişkeni tanımlar.
3. Yerel değişkeni kullanan mantığı içeren gerçek işlevi döndürür .

Dolayısıyla temel fark, ilk varyasyonda çubuğun yalnızca bir kez atanması, ikinci varyasyonun her çağrıldığında bu geçici değişkeni yaratmasıdır.

Bunun neden kullanıldığına dair en iyi tahminim, bar için örnek sayısını sınırlaması (yalnızca bir tane olacaktır) ve böylece bellek yönetimi ek yükünden tasarruf sağlamasıdır.

Sorularım:

1. Bu varsayım doğru mu?
2. Bu model için bir isim var mı?
3. Bu neden kullanılıyor?

Varsayımlarınız neredeyse doğru. Önce bunları gözden geçirelim.

1. Kendi kendine çalışan bir işlevin dönüşünü atar

Buna Anında çağrılan işlev ifadesi veya IIFE denir

2. Bu işlev içinde yerel bir değişkeni tanımlar

Bu, privateanahtar kelimeyi veya işlevi başka şekilde sağlamadığından JavaScript'te özel nesne alanlarına sahip olmanın bir yoludur .

3. Yerel değişkeni kullanan mantığı içeren gerçek işlevi döndürür.

Yine ana nokta, bu yerel değişkenin özel olmasıdır .

Bu model için bir isim var mı?

AFAIK bu kalıbı Modül Modeli olarak adlandırabilirsiniz . Alıntı yapmak:

Modül kalıbı, "gizlilik", durum ve organizasyonu kapatmaları kullanarak kapsüller. Herkese açık ve özel yöntemlerin ve değişkenlerin bir karışımını sarmanın, parçaların küresel kapsama sızmasını ve yanlışlıkla başka bir geliştiricinin arayüzüyle çarpışmasını önleyen bir yol sağlar. Bu modelle, yalnızca genel bir API döndürülür ve kapanış içindeki diğer her şey gizli tutulur.

Bu iki örneği karşılaştırdığımızda, ilkinin neden kullanıldığına dair en iyi tahminlerim şunlar:

1. Singleton tasarım modelini uygulamaktadır.
2. Birinci örnek kullanılarak belirli bir tipteki bir nesnenin yaratılma şekli kontrol edilebilir. Bu noktayla yakın bir eşleşme Etkili Java'da açıklandığı gibi statik fabrika yöntemleri olabilir .
3. Bu var verimli Aynı nesne devlete her zaman gerekiyorsa.

Ancak her seferinde vanilya nesnesine ihtiyacınız varsa, bu model muhtemelen herhangi bir değer katmayacaktır.

Nesne başlatma maliyetlerini sınırlar ve ek olarak tüm işlev çağrılarının aynı nesneyi kullanmasını sağlar . Bu, örneğin, gelecekteki çağrılar kullanmak üzere durumun nesnede depolanmasına izin verir.

Bellek kullanımını sınırlaması mümkün olsa da, genellikle GC zaten kullanılmayan nesneleri toplayacaktır, bu nedenle bu modelin pek bir faydası olmayacaktır.

Bu kalıp, belirli bir kapanış biçimidir .

Bu kalıbın daha doğru bir isme sahip olup olmadığından emin değilim, ancak bu bana bir modül gibi görünüyor ve kullanılmasının nedeni hem kapsüllemek hem de durumu korumak.

Kapanış (bir işlev içindeki bir işlevle tanımlanır), iç işlevin dış işlev içindeki değişkenlere erişmesini sağlar.

Verdiğiniz örnekte, iç işlev, foodış işlevin çalıştırılmasıyla döndürülür (ve atanır ); bu tmpObject, kapanış içinde yaşamaya devam ettiği anlamına gelir ve iç işleve birden çok çağrı, öğesinin foo()aynı örneğinde çalışır tmpObject.

Kodunuz ile Three.js kodu arasındaki temel fark, Three.js kodunda değişkenin tmpObjectyalnızca bir kez başlatılması ve ardından döndürülen işlevin her çağrısı tarafından paylaşılmasıdır.

staticDeğişkenlerin C benzeri dillerde nasıl kullanıldığına benzer şekilde, çağrılar arasında bazı durumları korumak için bu yararlı olacaktır .

tmpObject yalnızca iç işlev tarafından görülebilen özel bir değişkendir.

Bellek kullanımını değiştirir, ancak bellekten tasarruf etmek için tasarlanmamıştır.

Bu ilginç konuya, tüm yöntemlerin ve değişkenlerin açıkça açığa çıkıncaya kadar gizli tutulmasını sağlayan açığa çıkaran modül modeli kavramını genişleterek katkıda bulunmak istiyorum.

İkinci durumda, toplama yöntemi Calculator.add () olarak adlandırılır;

Verilen örnekte, ilk kod parçası foo () işlevine yapılan her çağrı için aynı tmpObject örneğini kullanacaktır; burada ikinci parçadaki gibi tmpObject her seferinde yeni bir örnek olacaktır.

İlk kod parçacığının kullanılmış olmasının bir nedeni, tmpObject değişkeninin, değeri foo () 'nun bildirildiği kapsama sızmadan foo () çağrıları arasında paylaşılabilmesidir.

İlk kod parçacığının hemen çalıştırılmayan işlev sürümü aslında şöyle görünecektir:

var tmpObject = new Bar();

function foo(){
    // Use tmpObject.
}

Ancak bu sürümün foo () ile aynı kapsamda tmpObject'e sahip olduğuna dikkat edin, bu nedenle daha sonra değiştirilebilir.

Aynı işlevselliği elde etmenin daha iyi bir yolu, ayrı bir modül kullanmaktır:

Modül 'foo.js':

var tmpObject = new Bar();

module.exports = function foo(){
    // Use tmpObject.
};

Modül 2:

var foo = require('./foo');

Bir IEF ile adlandırılmış bir foo oluşturucu işlevinin performansı arasında bir karşılaştırma: http://jsperf.com/ief-vs-named-function