Hi,

den Wert setzen will ich ja nicht. Dennoch hab ich das mit dem toString Methode nciht ganz verstanden?!.
Kannst du da vielleicht bitte ein Beispiel geben?

Wenn du ein JavaScript-Objekt in einem String-Kontext verwendest (also es bspw. per alert ausgeben laesst), welches aber nicht vom Typ String ist - dann muss ja irgendwie festgelegt werden, wie die Ausgabe dann lauten soll.

Dafuer haben solche Objekte eine toString-Methode, die implizit aufgerufen wird, wenn du das Objekt in einem Kontext benutzt, wo nur ein String gebraucht werden kann.

alert(document.body) beispielsweise wird dir "[object HTMLBodyElement]" (oder sowas aehnliches, je nach Browser - meine Beispielausgaben sind vom Opera) ausgeben. Es handelt sich also um ein Element vom Typ HTMLBodyElement - das laesst sich nicht direkt in einem Stringkontext "ausgeben", also liefert dessen toString-Methode eben jenen Text stattdessen.
alert(document.body.toString()) liefert das gleiche - das waere der direkte Aufruf. Bei der obigen Schreibweise wird die Methode auch aufgerufen, nur eben implizit.

Wenn wir mal dein Objekt aus deinem Eingangsposting nehmen,

function Klasse() {  
  this.obj = "was auch immer"  
}  
  
var Instanz = new Klasse;  
alert(Instanz.obj);

• da gibt uns der alert nur [object Object] aus; aus dem Grund, dass dein Objekt sich nicht als String darstellen laesst. Nach einer toString-Methode wurde dabei gesucht; dein Objekt hatte aber keine eigene, also wurde die des generellen Object-Typs von JavaScript aufgerufen, von dem dein Objekt sie geerbt hat - und das gibt ein Objekt eben nur als "Object" aus.

Wenn du jetzt aber deinem Objekt eine eigene Methode mit dem speziellen Namen toString verpasst - dann wird diese aufgerufen, sobald das Objekt irgendwo in einen Stringkontext ueberfuehrt werden muss. Und damit hast du die Kontrolle darueber, wie diese Ausgabe dann lautet - also kannst du sie bspw. auch den Wert der Objekt-Eigenschaft obj zurueckgeben lassen:

function Klasse() {  
  this.obj = "was auch immer";  
  
  this.toString = function() {  
    return this.obj;  
  };  
}  
  
var instance = new Klasse();  
alert(instance);

(Diese Methode muss natuerlich "public" sein, also mit dem Keyword this deklariert werden, denn sie muss ja von ausserhalb des Objektes aufrufbar sein.)

MfG ChrisB

gruss Timo,

Hat aber auch Nachteile:
...
D.h., die Regel "Wenn a gleich b und b gleich c, ist a gleich c" ist verletzt.
...

keineswegs ...

var MyOwnTypesConstructor = (function (typesValue) {  
  
 this.valueOf = (function () {  
  
  return typesValue;  
 });  
 this.toString = (function () {  
  
  return String(typesValue);  
 });  
});  
  
var o1 = new MyOwnTypesConstructor(0);  
var o2 = new MyOwnTypesConstructor(0);  
  
print("o1 == o2: " + (o1 == o2)); // false  
print("o1 == 0 : " + (o1 == 0));  // true  
print("o2 == 0 : " + (o2 == 0));  // true  
  
/*  
  

> var o1=new MyOwnTypesConstructor(0);  
> var o2=new MyOwnTypesConstructor(0);  
>   
> print("o1==o2: "+(o1==o2)); // false  
> print("o1==0:  "+(o1==0)); // true  
> print("o2==0:  "+(o2==0)); // true  
>   
> D.h., die Regel "Wenn a gleich b und b gleich c, ist a gleich c" ist verletzt.  
  
  
  ja und? - dass ergebnis ist keineswegs ueberraschend.  
  
  es werden auch keinerlei regeln verletzt; schliesslich  
  arbeiten wir hier mit objekten und nicht mit primitiven  
  typen bzw. werten.  
  
  die beim vergleichen zum tragen kommende automatische  
  typwandlung arbeitet JavaScript-regelkonform - siehe auch:  
*/  
  
print("(o1 === o2) ? " + (o1 === o2)); // false  
print("(o1 === 0)  ? " + (o1 === 0));  // false  
print("(o2 === 0)  ? " + (o2 === 0));  // false  
  
var num1 = new Number(0);  
var num2 = new Number(0);  
  
print("(num1 == num2) ? " + (num1 == num2)); // false ... objektreferenzen  
print("(num1 == 0)    ? " + (num1 == 0));    // true  ... typwandlung durch wert  
print("(num2 == 0)    ? " + (num2 == 0));    // true  ... typwandlung durch wert  
  
print("(num1 === num2) ? " + (num1 === num2)); // false ... objektreferenzen  
print("(num1 === 0)    ? " + (num1 === 0));    // false ... typwandlung ausgeschlossen  
print("(num2 === 0)    ? " + (num2 === 0));    // false ... typwandlung ausgeschlossen

mein fazit:

bei der dem OP aufgezeigten loesung handelt es sich um eine
nach ECMA 262 mustergueltige implementierung eigener objekttypen.

so long - peterS. - pseliger@gmx.net