proprietà vs var: quali sono le perfomance emette

Question

Im facendo un gioco del serpente in javascript e im creare gli oggetti e gameloops all'interno della funzione window.onload.

window.onload = function() { ... Code ... }; 

Ora mi chiedo sopra gli oggetti che la creazione all'interno dell'ambito della funzione viene utilizzata in modo efficiente? Qual è la differenza tra l'utilizzo di questi due tipi di dichiarazioni?

1:

var Snake = { 
    x: null, 
    y: null, 
    initialize: function(x, y) { this.x = x; this.y = y }, 
    position: [x, y], 
    move: function(x, y) { ... Code ... } 
} 

2:

function Snake(x, y) { 
    this.x = x; 
    this.y = y; 
    this.position = function() { return [this.x, this.y]; }; 
    this.move = function(x, y) { ... Code ... }; 
} 

Im attualmente utilizzando l'1: caso e chiamando gli oggetti dal campo di applicazione window.onload funzione, ad esempio sembra che questo:

Snake.initialize(x, y); 
while(some condition) { 
    Snake.move(x++, y); 
} 
and so on... 

c'è una differenza di allocazione di memoria e c'è qualche problemi di prestazioni ingegno h uno sopra l'altro?

Answer 1

Il primo metodo crea un solo oggetto utilizzando oggetto notazione letterale, mentre il secondo metodo utilizza il metodo funzione di costruzione che può creare più istanze dell'oggetto.

Ad esempio metodo 2 consente:

var snake1 = new Snake(1,2); 
var snake2 = new Snake(2,2); 
//now I have two snakes, however method 1 would only ever have one copy of snake. 

metodo 1 fornirà un'istanza globale dell'oggetto Snake per l'intera partita.

Creazione di più istanze di un oggetto c'è bisogno di più risorse, tuttavia in questo caso potrebbe non essere evidente. Se hai bisogno di un solo serpente nel tuo gioco usa il metodo uno, se hai intenzione di avere più serpenti, il metodo 2 è l'approccio giusto. Non mi preoccuperei delle prestazioni o dell'uso delle risorse finché non diventerà un problema all'interno del gioco.

Article on Constructor Function

Answer 2

Se solo uno Snake in tutto il programma (che è molto probabile) c'è, quindi il primo approccio è probabilmente la soluzione più semplice. Probabilmente non noterai la differenza di efficienza tra i due.

Se nel programma sono presenti più Snake (ad esempio si sta creando un multiplayer), il primo approccio non è sufficiente. L'oggetto Snake nel primo approccio a fronte di un Singleton in un linguaggio OOP, il che significa che hai solo una, in tutto il programma. Il secondo approccio è un costruttore (a fronte di una classe di ), il che significa che è possibile costruire più Snake istanze con proprietà diverse.

È ancora possibile migliorare questo secondo approccio memorizzando i metodi position e move su Snake.prototype invece di creare nuove funzioni in ogni chiamata del costruttore. Potrebbe non avere molta importanza per l'efficienza, ma otterrai un'eredità basata su prototipi che ti consentirà di creare altri costruttori (classi ) ereditando da Snake.