Javascript aggiungere metodo di opporsi

Question

Supponiamo che io sono un oggetto Foo

Come posso estendere questo oggetto con l'aggiunta di un metodo bar() e anche garantire che i futuri casi di Foo avere questo metodo?

Answer 1

è necessario aggiungerlo al prototipo di Foo:

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

Answer 2

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

• https://developer.mozilla.org/en-US/docs/JavaScript/Introduction_to_Object-Oriented_JavaScript

Di seguito funzionerà nel tuo esempio:

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

myFoo = new Foo(); 
myFoo.bar(); // Hello World​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ 

Answer 3

Puoi rendere bar una funzione rendendola un metodo.

Foo.bar = function(passvariable){ }; 

Come proprietà sarebbe solo essere assegnata una stringa, tipo di dati o booleano

Foo.bar = "a place"; 

Answer 4

Tutto questo dipende da come si sta creando Foo, e come si intende utilizzare .bar().

In primo luogo, stai utilizzando una funzione di costruzione per il tuo oggetto?

var myFoo = new Foo(); 

Se è così, allora si può estendere la proprietà della funzione Fooprototype con .bar, in questo modo:

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

var myFoo = new Foo(); 
myFoo.bar(); 

In questo modo, ogni istanza di Foo ha ora accesso al STESSO istanza di .bar.
Vale a dire: .bar avranno accesso completo ai this, ma avrà assolutamente nessun accesso-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, è possibile definire una funzione per restituire qualsiasi oggetto (non this), con .bar creato come una proprietà di tale oggetto:

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, tramite la cosiddetta chiusura, alle variabili "private" all'interno della funzione che ha restituito il loro oggetto particolare.
Ogni .bar ha ancora accesso al this così, come this, quando si chiama la funzione come myObj.bar(); sempre riferimento alla myObj (public_interface, nel mio esempio Foo).

Lo svantaggio di questo formato è che se si intende creare milioni di questi oggetti, si tratta anche di milioni di copie di .bar, che verranno conservate in memoria.

Si potrebbe anche fare questo all'interno di una funzione di costruzione, impostando this.bar = function() {}; all'interno del costruttore - ancora una volta, al di sopra sarebbe l'accesso di chiusura a variabili private nel costruttore e al ribasso sarebbero maggiori requisiti di memoria.

Quindi la prima domanda è:
cosa si aspetta i vostri metodi di avere accesso per leggere/modificare i dati "privati", che non è possibile accedere tramite l'oggetto stesso (attraverso this o myObj.X)?

e la seconda domanda è: Stai facendo abbastanza di questi oggetti in modo che la memoria sia una grande preoccupazione, se dai a ciascuno la propria funzione personale, invece di dar loro uno da condividere?

Per esempio, se ti ha dato tutti i loro .draw funzione in un gioco 3D di fascia alta triangolo e ogni consistenza, che potrebbe essere eccessivo, e sarebbe probabilmente interesserà 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ù).