Referenzen und Objekte bei Javascript

[Don P]

Hallo,

So besser?

Ja, allerdings.

function A(a)
{
   var a = a;

this.ausgeben = function ausgeben()
   {
      return a;
   }
}

function B(a)
{
   var a = a;

this.tuwas = function tuwas()
   {
      a = new A(new Array());
      //a ausgeben
   }
}

function C(meinarray)
{
   var meinA = new A(meinarray);

this.tuwas2 = function tuwas2()
   {
      var meinB = new B(meinA);
      meinB.tuwas();
      //Ausgabe von meinA
   }

this.ausgeben = function ausgeben()
   {
      return meinA.ausgeben();
   }
}

var c = new C(new Array("1", "2", "3"));
//meinA hat jetzt das Array gespeichert

Genauer: c verweist jetzt auf ein C-Objekt, und das kennt eine Variable meinA, die auf ein A-Objekt verweist, welches eine Variable a kennt, die auf das übergebene Array verweist.  
  

> c.tuwas2();  
> //Gibt jetzt kein leeres Array aus, sondern das Array mit den 3 Strings  
  
c.tuwas2 erzeugt und speichert zunächst in meinB ein B-Objekt, welches das A-Objekt (meinA) als Parameter bekommt und dieses in seiner Variablen a speichert:  

>       `var meinB = new B(meinA);`{:.language-javascript}  
  
Dann ruft c.tuwas2 noch die Methode tuwas seines B-objekts auf, die seine eigene Variable a mit einem leeren Array überschreibt (nur im B-objekt):  
  

>       `meinB.tuwas();`{:.language-javascript}  

Ausgegeben wird dabei nichts.  
  

> `c.ausgeben()`{:.language-javascript}  

Die ausgeben-Methode des C-Objekts ruft nun die gleichnamige Methode seines in meinA gespeicherten A-Objekts auf, welche das in seiner Variablen a nach wie vor referenzierte, ursprüngliche Array zurückgibt.  
  
Was hast du erwartet?  
Das B-Objekt kann seine eigene Variable a so oft überschreiben wie es will, kein anderes Objekt bekommt davon etwas mit.  
  

> Wenn ich von B hingegen eine Methode von A aufrufen lassen, mit der A etwas in sich selbst ändert, dann bleibt die Änderung "für immer".  
  
Ist klar.  
  

> Wie erreiche ich es nun, dass B quasi A "löscht"?  
  
Vielleicht, indem es "hingegen eine Methode von A" aufruft, "mit der A etwas in sich selbst ändert" ?  
  

> Ich könnte in tuwas2() natürlich einfach "meinA = new A(new Array());" schreiben, aber das möchte ich nicht.  
  
Warum nicht?  
  

> Geht das auch anders?  
  
Wenn du – wie im gezeigten Beispiel – sogenannte Closures verwendest (deine Variablen a in den A- und B-Objekten) dann kann auf diese nur von Methoden der Objekte zugegriffen werden, in denen sie auch definiert sind: Eine Methode im Konstruktor von A kann auf die Variable a einer A-Instanz zugreifen, und eine eine Methode im Konstruktor von B kann auf die Variable a einer B-Instanz zugreifen.  
  
Aber die Methode eine B-Instanz kann niemals direkt auf die Variable a einer A-Instanz zugreifen, und umgekehrt auch nicht.  
  
Wenn allerdings noch woanders eine Referenz auf denselben Wert existiert – also hier das Array – dann kann man diese andere Referenz verwenden, um das Array zu ändern, auf das in Closure-Variablen verwiesen wird.  
  
Gruß, Don P