Funktion nicht als Konstruktor

[Ferry Bolhar]

Hallo,

schreibe ich Code wie

var x = new Math;

bekomme ich - vollkommen richtig - einen Laufzeitfehler:

"Math is not a constructor"

Gibt es eine Möglichkeit, dieses Verhalten auch auf eine
selbstgeschriebene Funktion abzubilden? Oder allgemeiner
formuliert: wie kann ich innerhalb einer Funktion feststellen,
ob sie nun als normale Funktion oder als Konstruktor (über
"new") aufgerufen wurde?

LG, Ferry

--
Ing Ferry Bolhar
Magistrat der Stadt Wien - MA 14
A-1010 Wien
E-Mail: b...@adv.magwien.gv.at

[peterS.]

hallo again Ferry,

> schreibe ich Code wie
>
> var x = new Math;
>
> bekomme ich - vollkommen richtig - einen Laufzeitfehler:
>
> "Math is not a constructor"

dies ist ein anderes paar schuhe als jenes auf welches Du
Dich in Deiner weiter unten zitierten frage beziehst.

auch wenn die grossschreibung manchen zur annahme verleitet,
dass es sich hier um den [[Math]]-konstruktor handele, ist
[Math] nach aussen hin nichts weiter als ein einfaches objekt
mit allen in den spezifikationen beschriebenen eigenschaften.

> Gibt es eine Möglichkeit, dieses Verhalten auch auf eine
> selbstgeschriebene Funktion abzubilden? Oder allgemeiner
> formuliert: wie kann ich innerhalb einer Funktion feststellen,
> ob sie nun als normale Funktion oder als Konstruktor (über
> "new") aufgerufen wurde?

indem Du diese funktion weiterhin als konstruktor mit einer
bindung an den [this]-operator schreibst ...

http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Operators:Special_Operators:this_Operator#Description

... und innerhalb dieser
funktion pruefst, ob [this.constructor] einen anderen scope
als den der funktion selber referenziert - bsp:

var Foo = function (str) {

var foo = String(str);

this.toString = function () {
return foo;
};

//alert("constructor - alert(this) : " + this);
//alert("constructor - this.constructor : " + this.constructor);

//return this;

return ((this.constructor !== arguments.callee) ? (foo) : (this));
};

var foo = new Foo("foo"); // [Foo]-object;

alert(foo); // implizit [toString] : "foo"
alert(typeof foo); // "object"
alert(typeof foo.toString()); // "string"

foo = Foo(foo); // typecast: [string]-value

alert(foo); // ausdruecklich der string-value: "foo"
alert(typeof foo); // "string"
alert(typeof foo.toString()); // "string" (die antwort auf das warum
ist komplexer)

var bar = Foo("bar"); // typecast: [string]-value

alert(bar); // ausdruecklich der string-value: "bar"
alert(typeof bar); // "string"
alert(typeof bar.toString()); // "string" (die antwort auf das warum
ist komplexer)

das beispiel lehnt sich an die dualismen von [[String]],
[[Number]] und [[Boolean]] an - mit dem >>new<<-operator
als konstruktoren aufgerufen, erzeugen diese funktionen
[String]-, [Number]- bzw. [Boolean]-OBJEKTE; als simple
funktionen erzwingen sie die typumwandlung des arguments
hin zu einem string-, number-, bzw. boolean-value (also
hin zu einem *primitiven* WERT).

so long - peterS. - psel...@gmx.net