Ist es möglich, eine Methode aus einer Objektdefinition Konstruktor Funktion

Question

aufrufen Sagen wir haben eine Konstruktorfunktion in JavaScript, die ich verwenden, um meine Objekte zu erstellen. Wie würde ich den "Inhalt" aller Objekte ändern, die von dieser Funktion durch einen Methodenaufruf von dieser Funktion erstellt werden. Ich frage mich, ob es möglich ist, einen Methodenaufruf auf den Prototyp aufzurufen, so wie wir den Prototyp modifizieren und unsere eigenen Methoden/Eigenschaften hinzufügen würden.

Zum Beispiel:

function MyConstructor() 
{ 
    var privateVariable = "This is an ORIGINAL private variable"; 
    this.publicVariable = "This is public"; 

    this.modificationMethod = function(){ 
    // I want to call this methode on the prototype 
    privateVariable = "I am now changed"; 
    }; 

    this.alertMe = function(){ 
     alert(privateVariable); 
    }; 
} 

var a = new MyConstructor(); 
a.alertMe();  // alerts This is an ORIGINAL private variable 
a.modificationMethod(); 
a.alertMe();  // alerts I am now changed 

Dies funktioniert, wenn ich ein einzelnes Objekt zu ändern, ich die Methode aufrufen, ändert es das einzelne Objekt. Ich möchte jedoch alle Objekte ändern, die vom Konstruktor erstellt werden.

Ich weiß, dass ich neue Methoden, um es wie folgt hinzufügen:

MyConstructor.prototype.foo = function(){ 
    alert("foo"); 
} 
a = new MyConstructor(); 
a.foo(); 

Aber es lässt mich nicht die bestehenden Methoden ausführen, um die Eigenschaften zu ändern, und wirft einen Fehler:

MyConstructor.prototype.modificationMethod(); 

"modificationMethod ist keine Funktion"

Answer 1

BEARBEITEN: Aktualisieren der Antwort, um alles widerzuspiegeln in Kommentaren gequält. Ich habe das Problem des OP zunächst falsch verstanden.

---

Jedes Objekt ist mit einem Prototyp-Objekt verknüpft. Beim Versuch, auf eine Eigenschaft zuzugreifen, die nicht existiert, sucht JavaScript im Prototypobjekt des Objekts nach dieser Eigenschaft und gibt es zurück, wenn es existiert.

Die Prototypeigenschaft eines Funktionskonstruktors bezieht sich auf das Prototypobjekt aller Instanzen, die mit dieser Funktion erstellt wurden, wenn new verwendet wird.

Was das bedeutet ist, dass Prototyp-Objekt eine Art Fallback-Mechanismus ist, wenn ein Objekt selbst nicht die gewünschte Eigenschaft hat.

---

Das Konzept der privaten Variablen sind in der Tat closures.

Prototyp-Funktionen sind außerhalb des Konstruktorfunktionsbereichs definiert, dh sie können nicht auf die "privaten Eigenschaften" zugreifen.

Es ist jedoch möglich, der Prototypeigenschaft selbst eine Schließung zuzuweisen, wodurch effektiv eine private gemeinsame (statische) Variable erstellt wird.

function MyConstructor() {}; 

MyConstructor.prototype = (function() { 

    var extensions = { 
    foo: null, 
    test: function() { 
     alert("Test was extended"); 
    } 
    }; 

    return { 
    registerExtension: function(name, callback) { 
     extensions[name] = callback; 
    }, 
    // in order to use the extensions object, you need a generic function such as invoke 
    invoke: function(name) { 
     if (typeof extensions[name] === 'function') 
     extensions[name].call(this); 
    } 
    }; 

}()); 

var a = new MyConstructor(); 
a.invoke('test'); //will alert 
a.invoke('foo'); //will not alert (not a function) 
a.registerExtension('foo', function() { 
    alert("foo is now extended as well"); 
}); 
a.invoke('test'); //will alert 
a.invoke('foo'); //will alert 

---

Ein einfacher Ansatz, wenn Sie für die erweiterten Funktionen nichts dagegen sichtbar (öffentlich) zu sein, wäre direkt die prototype erstrecken.

function MyConstructor() {}; 

MyConstructor.prototype = { 
    foo: null, 
    test: function() { 
    alert("Test was extended"); 
    } 
}; 

var a = new MyConstructor(); 
a.test(); //will alert 
//a.foo(); //will not alert (not a function) 
MyConstructor.prototype.foo = function() { 
    alert("foo is now extended as well"); 
}; 
a = new MyConstructor(); 
a.test(); //will alert 
a.foo(); //will alert 

Sie können problemlos eine Schnittstelle für die Erweiterung des Prototyps erstellen.

Object.prototype.registerExtension = function(name, func){ 
    this.prototype[ name ] = func; 
}; 

// ... 

MyConstructor.registerExtension('foo', function() { 
    alert("foo is now extended as well"); 
});