Javascript aggiunge il metodo all’object

Supponiamo che io abbia un object Foo

Come posso estendere questo object aggiungendo un metodo bar() e assicurarmi che le future istanze di Foo abbiano questo metodo?

devi aggiungerlo al prototipo di Foo:

 function Foo(){} Foo.prototype.bar = function(){} var x = new Foo() x.bar() 

Tutto dipende da come stai creando Foo e da come intendi usare .bar() .

Innanzitutto, stai usando una funzione di costruzione per il tuo object?

 var myFoo = new Foo(); 

In tal caso, puoi estendere la proprietà prototype della funzione Foo con .bar , in questo modo:

 function Foo () { /*...*/ } Foo.prototype.bar = function () { /*...*/ }; var myFoo = new Foo(); myFoo.bar(); 

In questo modo, ogni istanza di Foo ora ha accesso all’istanza SAME di .bar .
Per .bar : .bar avrà accesso FULL a this , ma non avrà assolutamente accesso alle variables all’interno della funzione di costruzione:

 function Foo () { var secret = 38; this.name = "Bob"; } Foo.prototype.bar = function () { console.log(secret); }; Foo.prototype.otherFunc = function () { console.log(this.name); }; var myFoo = new Foo(); myFoo.otherFunc(); // "Bob"; myFoo.bar(); // error -- `secret` is undefined... // ...or a value of `secret` in a higher/global scope 

In un altro modo, puoi definire una funzione per restituire qualsiasi object (non this ), con .bar creato come una proprietà di quell’object:

 function giveMeObj () { var private = 42, privateBar = function () { console.log(private); }, public_interface = { bar : privateBar }; return public_interface; } var myObj = giveMeObj(); myObj.bar(); // 42 

In questo modo, hai una funzione che crea nuovi oggetti.
Ognuno di questi oggetti ha una funzione .bar creata per loro.
Ogni funzione .bar ha accesso, attraverso quello che viene chiamato closure , alle variabili “private” all’interno della funzione che ha restituito il loro object particolare.
Ogni .bar ha ancora accesso a this , come this , quando chiami la funzione come myObj.bar(); farà sempre riferimento a myObj ( public_interface , nel mio esempio Foo ).

Lo svantaggio di questo formato è che se creerai milioni di questi oggetti, saranno anche milioni di copie di .bar , che mangeranno in memoria.

Puoi anche farlo all’interno di una funzione di costruzione, impostando this.bar = function () {}; all’interno del costruttore – di nuovo, al rialzo sarebbe l’accesso alla chiusura di variabili private nel costruttore e il lato negativo sarebbe un aumento dei requisiti di memoria.

Quindi la prima domanda è:
Ti aspetti che i tuoi metodi abbiano accesso alla lettura / modifica dei dati “privati”, a cui non è ansible accedere tramite l’object stesso (tramite this o myObj.X )?

e la seconda domanda è: stai facendo abbastanza di questi oggetti in modo che la memoria sarà una grande preoccupazione, se darai a ciascuno la loro funzione personale, invece di dar loro uno da condividere?

Ad esempio, se hai dato a ogni triangolo e ogni texture la propria funzione .draw in un gioco 3D di fascia alta, questo potrebbe essere eccessivo e probabilmente influenzerebbe il framerate in un sistema così delicato …

Se, tuttavia, stai cercando di creare 5 barre di scorrimento per pagina, e vuoi che ognuno sia in grado di impostare la sua posizione e tenere traccia di se viene trascinato, senza consentire ad ogni altra applicazione di accedere a leggere / impostare le stesse cose , quindi non c’è davvero alcun motivo per avere paura che 5 funzioni extra stiano per uccidere la tua app, supponendo che potrebbe essere già lunga 10.000 righe (o più).

Esistono molti modi per creare oggetti riutilizzabili come questo in JavaScript. Mozilla ha una bella introduzione qui:

Quanto segue funzionerà nel tuo esempio:

 function Foo(){ this.bar = function (){ alert("Hello World!"); } } myFoo = new Foo(); myFoo.bar(); // Hello World​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ 

Puoi rendere bar una funzione rendendola un metodo.

 Foo.bar = function(passvariable){ }; 

Come proprietà, verrebbe assegnata una stringa, un tipo di dati o un valore booleano

 Foo.bar = "a place";