Perché coffeescript genera classi come questa?

Question

Dato il seguente codice CoffeeScript:

class Animal 
    constructor: (@name) -> 
    speak: (things) -> "My name is #{@name} and I like #{things}" 

Viene generato:

var Animal = (function() { 
    function Animal(name) { 
    this.name = name; 
    } 
    Animal.prototype.speak = function(things) { 
    return "My name is " + this.name + " and I like " + things; 
    }; 
    return Animal; 
})(); 

Ma perché non viene generato questo codice più idiomatica?

var Animal = function Animal(name) { 
    this.name = name; 
}; 
Animal.prototype.speak = function(things) { 
    return "My name is " + this.name + " and I like " + things; 
}; 

so che CoffeeScript avvolge un sacco di roba in funzioni anonime per controllare la portata delle perdite, ma ciò che potrebbe fuoriuscire qui?

Answer 1

Il codice generato consente di assegnare in modo affidabile funzioni con nome in Internet Explorer. (In questo caso, "Animale".) Se si utilizza semplicemente una funzione con nome in ambito superiore, sarà in conflitto con tutte le dichiarazioni var Animal = che potrebbero essere presenti ... anche in ambiti inferiori, impedendo loro di fare riferimento correttamente. Per ovviare al bug di IE, includiamo la funzione wrapper attorno alla definizione della classe.

Answer 2

Questo serve per supportare i backtrace inclusi i nomi di classe e non solo i nomi di funzioni quando viene generata un'eccezione.

Answer 3

Il metodo CoffeeScript presenta anche vantaggi per la minificazione.

Da my other answer:

Per la maggior parte delle classi ragionevoli, la chiusura generata dal CoffeeScript genera uscita minimizzato minore. L'involucro chiusura è 25 byte di overhead minimizzato, ma si evita di ripetere il nome classe, risparmiando k * N byte (k = lettere-in-nome, N = num-di-ref). ad esempio, se una classe come BoilerPlateThingyFactory ha 2+ metodi, il wrapper di chiusura genera un codice minisito più piccolo.

---

più in dettaglio ...

The Coffee Codice generato usando una chiusura a minifies:

// Uglify '1.js' = 138 bytes (197 w/ whitespace): 

var Animal=function(){function e(e){this.name=e}return e.prototype.speak=function(e){return"My name is "+this.name+" and I like "+e},e}(); 

// with whitespace ("uglifyjs -b"): 

var Animal = function() { 
    function e(e) { 
     this.name = e; 
    } 
    return e.prototype.speak = function(e) { 
     return "My name is " + this.name + " and I like " + e; 
    }, e; 
}(); 

alternative di ryeguy "idiomatiche" minifies implementazione a questo :

// Uglify '2.js' = 119 bytes (150 w/ whitespace): 

var Animal=function(t){this.name=t};Animal.prototype.speak=function(e){return"My name is "+this.name+" and I like "+e}; 

// with whitespace ("uglifyjs -b"): 

var Animal = function(t) { 
    this.name = t; 
}; 

Animal.prototype.speak = function(e) { 
    return "My name is " + this.name + " and I like " + e; 
}; 

Nota come il nome "Animale" esista esattamente una volta nella forma Caffè e N = 2 volte nella varietà "idiomatica" di Ryeguy. Ora "Animale" ha solo 6 lettere, e c'è solo 1 metodo, quindi Coffee qui dovrebbe perdere di 25-6 = 19 byte. Consultando il mio codice miniato, è 138 byte a 119 byte, per un delta di ... 19 byte. Aggiungi altri 4 metodi e il vantaggio passerà a Coffee. E non sono solo i metodi; anche le costanti di classe e altri tipi di ref.