Miért beágyazni a JavaScript osztály egy névtelen függvény () hívás?

Question

Miért beágyazni a JavaScript osztály egy névtelen függvény () hívás?

szavazat

17

Olvastam az új JavaScript-szerű nyelvet a Microsoft nevű géppel . A játszótéri (például részben) , van egy egyszerű osztályú géppel szintaxis alakítjuk JavaScript kódot. Jön egy Java programozási háttérrel, érdekes volt számomra, hogy megtanulják, hogyan OOP történik JavaScript összeállított géppel.

A géppel kód:

class Greeter {
    greeting: string;
    constructor (message: string) {
        this.greeting = message;
    }
    greet() {
        return Hello,  + this.greeting;
    }
}   

var greeter = new Greeter(world);

var button = document.createElement('button')
button.innerText = Say Hello
button.onclick = function() {
    alert(greeter.greet())
}

document.body.appendChild(button)

És az azzal egyenértékű JavaScript kód:

var Greeter = (function () {
    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return Hello,  + this.greeting;
    };
    return Greeter;
})();
var greeter = new Greeter(world);
var button = document.createElement('button');
button.innerText = Say Hello;
button.onclick = function () {
    alert(greeter.greet());
};
document.body.appendChild(button);

A géppel része nagyon hasonlít a Java, így értem. Most a kérdés, hogy miért a JavaScript a szervezetben az Greeterosztály van ágyazva egy névtelen function()hívást?

Miért nem írja meg, mint ez?

function Greeter(message) {
    this.greeting = message;
}
Greeter.prototype.greet = function () {
    return Hello,  + this.greeting;
};

Mi az előnye / hátránya az egyes módszerek?

javascript typescript

A kérdést 02/10/2012 15:27
a forrás felhasználó AlexStack

Más nyelveken...

6 válasz

szavazat

3

Amellett, hogy nyilvánvaló felmérő / bezárása érvelés. Segítségével egy névtelen függvény, amely meghívja magát azonnal pre-terhelés (értelmezi) az osztály definíciója. Ez lehetővé teszi, hogy bármely JIT optimalizáció kell elöltöltős belül a végrehajtást. Röviden, a nagyobb bonyolultabb alkalmazásoknál javítja a teljesítményt.

Válaszolt 02/10/2012 15:44
a forrás felhasználó Louis Ricci

szavazat

2

Ez lehetővé teszi a magán tagok. Ebben a példában minden tagja nyilvános, így a két konstrukciót egyenértékű. Azonban, ha azt szeretnénk, hogy a magán tagok el kell rejteni őket a hívó hatálya keresztül záródik. Így ha van egy saját tag például így:

class Greeter {
    private greeting: string;
    constructor (message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

Akkor valószínűleg ehhez hasonló lesz:

var Greeter = (function () {
    var greeting="";
    function Greeter(message) {
        greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + greeting;
    };
    return Greeter;
})();

Az üdvözlő változó elérhető lesz bármely függvény belsejében névtelen függvényt, de láthatatlan mindenhol máshol.

Válaszolt 02/10/2012 15:36
a forrás felhasználó Mark Porter

szavazat

2

A névtelen függvény / önvégrehajtás lezárás általában burkolására használt körét úgy, hogy csak a visszaadott érték elérhető kívül. (Vagy bármi csatolja más tárgyak, például ablak)

Válaszolt 02/10/2012 15:31
a forrás felhasználó Jordan Denison

szavazat

1

A névtelen függvény valószínűleg ott, hogy megakadályozzák név collition más részein a kódot. Gondoljunk csak bele, belül a névtelen függvényt, ha lehet még, hogy egy változót a „$”, hogy amit akarsz, és ugyanabban az időben, legyen jQuery más részein a kódot konfliktus nélkül.

Válaszolt 02/10/2012 15:31
a forrás felhasználó Deleteman

szavazat

-4

A lezárás az egyetlen jelenti, hogy hívja a konstruktőrök paraméterekkel:

var w = new Greeter("hello")

Vannak más módszerek is, de minden bonyolult és korlátozásokat és hátrányokat.

Válaszolt 18/07/2014 09:13
a forrás felhasználó Thinol

xandercoded · Accepted Answer · 2012-10-02 15:30

A következő nevezzük Azonnal meghívás funkció Expression :

(function(){ ... })();

Arra használják, hogy a globális hatókörű tiszta. Bár ebben az esetben nem szükséges, mivel a visszatérési érték van rendelve egy változó Greeter. Az egyetlen alkalom, ez a minta hasznos lehet, ha azt szeretné, „privát” statikus tagok.

Például:

var Greeter = (function () {
    var foo = 'foo', bar = 'bar'; /* only accessible from function's defined
                                     in the local scope ... */

    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + this.greeting;
    };
    return Greeter;
})();