selbstreferenzierung von js-objekten

[peterS.]

gruss Jürgen,

Also wie im Eröffnungsposting;
...
...
aber offensichtlich geht so etwas nicht.
Daher die "schlechte" Lösung:
function test(name) {
alert(name);
}
und
ABC=new test("ABC");

naja, selbst wenn diese loesung "schlecht" sein sollte, so
   ist sie doch legitim - das hab' ich doch weiter oben schon
   so ge- und beschrieben;

es gibt aber dennoch eine moeglichkeit, das "referenzloch"
   zwischen einem js-objekt und dem zugriff auf dieses objekt
   oder auf eine seiner eigenschaften bzw. dem aufruf einer
   seiner methoden aus einer dynamisch geschriebenen client-
   oberflaeche heraus elegant zu ueberbruecken;

das wird jetzt etwas laenger - vorueberlegungen:

a) kann man fuer den einsatz seiner selbstgeschriebenen
      konstruktor-funktionen immer sicherstellen, das diesem
      der name der zu initilisierenden objekt-variable ueber-
      geben wird? - nicht zweifelsfrei;

dieser, die ganze zeit als "dreckig" diskutierte ansatz,
      faellt also aus, obwohl es schon sehr nahe liegt, namen
      von globalen variablen ueber deren uebergeordnetes objekt
      "window" zu benutzen - bsp.:

die globale definition einer variablen "testObject" kann
      in einem js-client hoechst unterschiedlich ausfallen -

var testObject = new Object(); testObject.status = "test";
      //oder aber
      window.testObject = {status:"test"}; // aber auch
      window["testObject"] = {status:"test"};

in der letzten zeile steckt dann der schluessel fuer die
      referenzierung auf ein objekt, dessen variablen-namen
      bekannt ist (z.b. einer konstruktor-funktion, die diesen
      string-wert einem objekt mit auf dem weg gibt);
      zur referenzierung dient dann ein string, der auch in die
      oberflaeche des html-clients geschrieben werden kann:

"alert(window['" + variablenName + "'].status);"

b) wie kann man den ansatz aus a) - zuhilfenahme einer
      "string-referenz" - retten, obwohl a) verworfen
      werden muss?

es gibt zwei globale objekte im js-faehigen html-client:
      "window" als oberste "instanz" fuer alle "HTMLElement"-
      objekte und "Object" als oberste "instanz" fuer alle
      js-objekte;
      wenn kein string-wert (KEY) fuer den namen einer objekt-
      variablen verwendet werden darf, wie sieht es dann mit
      einer anderen form der "speicherung" aus - z.b.: INDEX?

das ist es - loesung:

(zum besseren verstaendnis werden nur die fundamentalen
       bestandteile vorgestellt, das ergebnis ist dann zwar
       funktionstuechtig aber in seiner gesamtheit angreifbar)

c) man erweitert das oberste js-objekt "Object" um ein array,
      dessen eintraege referenzen auf js-objekte jeglicher art
      sein sollen:

Object.selfReferences = [];

desweiteren benoetigt jedes js-objekt eine setter- bzw.
      getter-methode fuer seine referenz - beide methoden
      werden als prototypen ueber "Object" implementiert;

bei benutzung des setters "setSelfReference" wird dem
      array "Object.selfReferences" die referenz des aufruf-
      enden objekts hinzugefuegt - gleichzeitig bekommt das
      aufrufende objekt die eigenschaft "selfIndex" zugewiesen,
      deren numerischer wert dem index der objektreferenz im
      genannten array entspricht:

Object.prototype.setSelfReference = function() {
        this.selfIndex = Object.selfReferences.length;
        Object.selfReferences[this.selfIndex] = this;
      };

vor der umsetzung des getters soll noch einmal an den
      zweiten teil von a) mit dem fiktiven ergebnis -
      "alert(window['" + variablenName + "'].status);" -
      erinnert werden - etwas in der art, bezogen auf
      "Object.selfReferences", soll dabei schon herauskommen;

der rueckgabewert soll ein string sein, der in seiner
      evaluierten form, den zugriff auf das die getter-methode
      aufrufende objekt zulaesst - also so:

"Object.selfReferences[0]"

Object.prototype.getSelfReference = function() {
        return ("Object.selfReferences[" + this.selfIndex + "]");
      };

der einsatz eines an "Object" gebundenen arrays und die
      verfuegbarkeit von setter- und getter-Object-prototypen
      ermoeglicht es jedem js-objekt(auch teil-objekten eines
      js-objektes) referenzen auf denkbar einfache weise und
      unabhangig von den namen moeglicher objektvariablen zu
      schreiben und zu lesen;

einem einsatz steht jetzt nichts mehr im wege - nur -

der bis hierher vorgestellte loesung fehlt es an einer
      methode, selbstreferenzen sauber zu loeschen, oder aber
      das array von "unsauber" auf null gesetzten referenzen
      zu befreien;

die runde komplettloesung implementiert deshalb folgende
      eigenschaften:

das array   : Object.selfReferences;
      die methode : Object.selfReferences.isFragmented;
      die methode : Object.selfReferences.defragment;
      die methode : [obj].setSelfReference;
      die methode : [obj].getSelfReference;
      die methode : [obj].removeSelfReference;

nachzuschauem unter:
      http://www.pseliger.de/jsExtendedApi/jsApi.Object.selfReferences.dev.js
      anzuwenden mit:
      http://www.pseliger.de/jsExtendedApi/jsApi.Object.selfReferences.js

doch nun zuruck zum konstruktor "JB_Table":

die methoden "VglFkt" und "sort" lassen sich auch als
   prototypen-methoden von "JB_Table" umsetzen, wenn einige
   lokale variablen des konstruktors wie z.b. "ssort" jedem
   "JB_Table"-objekt als eigenschaften mitgegeben werden (this);

function JB_Table(tabId,vorsort) {
     this.setSelfReference();
     this.tabId = tabId;
     //Dein code;
   }
   JB_Table.prototype.vglFkt = function(a,b) {
     //Dein code
   };
   JB_Table.prototype.sort = function(s) {
     //Dein code
   };

die globale funktion "Text2Link" kann jetzt auch als
   prototypen-methode fuer das objekt "JB_Table" umgesetzt
   werden:

JB_Table.prototype.text2Link = function() {
     //moeglicherweise:
     var action = "javascript:" + this.getSelfReference() + ".sort(";
     //for(var i=0;i<5;i++) Text2Link("Kopf0_"+i,"javascript:Tabelle1.sort("+i+")") ;
     //die zeile hier darueber muss dahingehend abgewandelt
     //werden, dass ueber "this.tabId" auf den "tr"-knoten
     //zugegriffen wird, welcher die zu aendernden "td"-
     //knoten enthaelt; die knoten werden einzeln durch
     //gezaehlt und angepasst - vielleicht so: action + i + ")"
     //Dein code;
   };

viel erfolg - gute nacht - peterS. - [e-mail]