Un dubbio sull'assegnare alla proprietà di un oggetto una funzione tra un mio set di funzioni tali da svolgere un'operazione sulla/e proprietà dell'oggetto.
Nel primo caso (a) le funzioni fanno parte del prototype dell'oggetto, nel secondo (b) no. Il primo mi sembra più "corretto", almeno come leggibilità.
(a)
function MyObj() { this.counter = 100; this.func = this.funcOne; // or this.funcTwo or ... }
MyObj.prototype.funcOne = function () { this.counter++; };
MyObj.prototype.funcTwo = function () { this.counter--; };
var obj = new MyObj(); obj.func();
(b)
function func1() { this.counter++; }
function func2() { this.counter++; }
function MyObj() { this.counter = 100; this.func = func1; // or func2 or ... }
var obj = new MyObj(); obj.func();
ha senso lambiccarsi il cervello su ste robe? o una vale l'altra? visto che il risultato mi sembra lo stesso.
indubbiamente performance, se crei 1000 oggetti le funzioni che aggiungi al prototype vengono create una volta sola, nell'altro caso ogni oggetto ha una copia della funzione.
per il resto formalmente se vuoi avere una parvenza di ereditarietà usare il prototype è più corretto.
[QUOTE=Oath;18782222]indubbiamente performance, se crei 1000 oggetti le funzioni che aggiungi al prototype vengono create una volta sola, nell’altro caso ogni oggetto ha una copia della funzione.[/QUOTE]
Se non ricordo male questo non è un problema, javascript crea un solo oggetto in memoria per il codice di ogni funzione che scrivi, il resto sono solo puntatori.
La grossa differenza che vedo è che nel caso (b) hai comunque creato delle funzione nello scope in cui le hai scritte e quindi dipende dove le scrivi.
Se le scrivi a livello di scope globale saranno visibili da tutto il codice (e “ruberanno” gli identificativi).
[QUOTE=gerryino;18782475]Se non ricordo male questo non è un problema, javascript crea un solo oggetto in memoria per il codice di ogni funzione che scrivi, il resto sono solo puntatori.
[/QUOTE]
la differenza di performance c’e’, quindi secondo me quello che dici non e’ vero.
Nel senso che magari ci sono delle ottimizazioni dietro per cui alla fine viene creato un solo oggetto, ma comunque istanziare l’oggetto richiede piu’ tempo.
Poi oh, se non devi creare 20000 oggetti anche sticazzi, conosco gente che non usa prototype perche’ ama usare variabili private e con prototype non puoi fare questo:
var myObj = function(){
var thisIsPrivate = 0;
this.someMethod = function(){
return thisIsPrivate++;
}
}
comunque la parte 'hot' del mio dubbio è quella che ho ora evidenziato in giallo e dovrebbe essere sia in (a) che (b) l'assegnazione di un riferimento.
solo che in (a) è un riferimento ad una funzione del prototype, nel caso (b) riferimento a una funzione definita nello scope globale di node o oggetto window nel browser.
non CREDO che nel caso (b) la funzione venga duplicata per intero per ogni oggetto creato, se lo fosse, un motivo in più per non usare quel metodo, oltre la bruttezza
[QUOTE=Nemo;18783044]comunque la parte ‘hot’ del mio dubbio è quella che ho ora evidenziato in giallo e dovrebbe essere sia in (a) che (b) l’assegnazione di un riferimento.[/QUOTE]
la parte in giallo si, viene ripetuta per ogni oggetto che instanzi.
Infatti nel tuo caso non c’e’ differenza, ma perche’ cmq e’ un modo strano di usare prototype
Altro vantaggio di usare prototype e’ che se hai 500 oggetti e vuoi cambiare la funzione func, in un caso devi modificarla per tutti gli oggetti, nel secondo caso basta cambiare quella del prototype.
[QUOTE=RosaleX;18783206]Non capisco però perché nel caso (a) fai il passaggio evidenziato in giallo, quando ti basterebbe chiamare funcOne() dall’oggetto creato:
var obj = new MyObj();
obj.funcOne();
[/QUOTE]
Perché negli esempio ho semplificato. Nel caso reale potrei voler inizializzare func con funcOne o funcTwo a seconda di altri parametri passati al costruttore, tipo:
[QUOTE=Oath;18783227]Altro vantaggio di usare prototype e’ che se hai 500 oggetti e vuoi cambiare la funzione func, in un caso devi modificarla per tutti gli oggetti, nel secondo caso basta cambiare quella del prototype.[/QUOTE]
Uhm credo che in entrambi i miei esempi (a) e (b) i cambiamenti alle funzioni funcOne/Two e func1/func2 si riflettano live su tutti gli oggetti già istanziati e futuri.
[QUOTE=Nemo;18783363]
Uhm credo che in entrambi i miei esempi (a) e (b) i cambiamenti alle funzioni funcOne/Two e func1/func2 si riflettano live su tutti gli oggetti già istanziati e futuri.[/QUOTE]
si, scusa, parlavo in generale;
il modo in cui tu usi il prototype nell’esempio non penso ci sia nessuna differenza, a parte estetica
[/QUOTE]