An object's constructor name as a string. Can definitely be determined?

[Peter Michaux]

Hi,

I want to know the name of an object's constructor function as a
string. Something like this

<script type="text/javascript">
function Foo(){};
var a = new Foo();
alert('"' +
a.constructor.t oString().match (/function\s*([a-zA-Z\$][\w\$]+)[^\w\$]/)[1]
+ '"');
</script>

Although this works in IE, Opera, Firefox, Safari I'm not sure that it
is guaranteed to work.

I looked in the ECMA-262 specs about the returned string for
Function.protot ype.toString() in section 15.2.4.2. It says that the
whitespace, line terminators and semi-colon use are implementation
dependent. I think the above regular expression can handle those
difference.

What I'm worried about is that he specs say the return value has the
form of a "function declaration". Does that mean the returned string
will definitely contain the name of the constructor function? Could it
instead return something like just "function () {}"?

Thank you,
Peter

[RobG]

Peter Michaux wrote:

Hi,

I want to know the name of an object's constructor function as a
string. Something like this

<script type="text/javascript">
function Foo(){};
var a = new Foo();
alert('"' +
a.constructor.t oString().match (/function\s*([a-zA-Z\$][\w\$]+)[^\w\$]/)[1]
+ '"');
</script>

[...]

What I'm worried about is that he specs say the return value has the
form of a "function declaration". Does that mean the returned string
will definitely contain the name of the constructor function? Could it
instead return something like just "function () {}"?

A quick test shows that you can use an anonymous function as a
constructor, and it is returned in the form of a function declaration,
but it's actually a statement:

var nameObj = function(name){
this.name = name;
this.showName = function(){aler t(this.name);}
}

var x = new nameObj('Peter' );
x.showName();
alert(x.constru ctor);

shows:

function (name) { ...}

which only makes sense as a function statement. I guess you could say
it's in the form of a declaration because the left hand side is
missing. Of course you might fix that with:

var nameObj = function nameObj (name){ ... }

But that may not be helpful. In some browsers the constructor object
has a name property, but not all unfortunately. Can I be of any less
help? :-)
--
Rob

[Douglas Crockford]

Peter Michaux wrote:

Hi,

I want to know the name of an object's constructor function as a
string. Something like this

<script type="text/javascript">
function Foo(){};
var a = new Foo();
alert('"' +
a.constructor.t oString().match (/function\s*([a-zA-Z\$][\w\$]+)[^\w\$]/)[1]
+ '"');
</script>

Although this works in IE, Opera, Firefox, Safari I'm not sure that it
is guaranteed to work.

No, it's not. I don't like object models where it is necessary to query
instances about their types. But if you feel you must, make it reliable. The
constructor property is not reliable because it is lost in the simple
inheritance pattern:

function Bar(){}
Bar.prototype = new Foo();

var b = new Bar();
alert(b.constru ctor === Bar); // produces false

So be explicit in identifying your type names.

Foo.prototype.t ype = 'Foo';
Bar.prototype.t ype = 'Bar';

alert(a.type);
alert(b.type);

http://javascript.crockford.com/

[Peter Michaux]

RobG wrote:

Peter Michaux wrote:

Hi,

I want to know the name of an object's constructor function as a
string. Something like this

<script type="text/javascript">
function Foo(){};
var a = new Foo();
alert('"' +
a.constructor.t oString().match (/function\s*([a-zA-Z\$][\w\$]+)[^\w\$]/)[1]
+ '"');
</script>

[...]

What I'm worried about is that he specs say the return value has the
form of a "function declaration". Does that mean the returned string
will definitely contain the name of the constructor function? Could it
instead return something like just "function () {}"?

A quick test shows that you can use an anonymous function as a
constructor, and it is returned in the form of a function declaration,
but it's actually a statement:

var nameObj = function(name){
this.name = name;
this.showName = function(){aler t(this.name);}
}

var x = new nameObj('Peter' );
x.showName();
alert(x.constru ctor);

shows:

function (name) { ...}

which only makes sense as a function statement. I guess you could say
it's in the form of a declaration because the left hand side is
missing. Of course you might fix that with:

var nameObj = function nameObj (name){ ... }

But that may not be helpful. In some browsers the constructor object
has a name property, but not all unfortunately. Can I be of any less
help? :-)

Hi Rob,

I tested the things you mentioned also. It seems the the return value
of toString() can take the form of a function statement when the
function is anonymous. So does this mean the ECMA specs are a little
bit wrong? If a function is anonymous, there is no way that toString
will be able to return a function declaration since the identifier is
not available.

Thanks,
Peter

[VK]

Peter Michaux wrote:

It seems the the return value
of toString() can take the form of a function statement when the
function is anonymous. So does this mean the ECMA specs are a little
bit wrong? If a function is anonymous, there is no way that toString
will be able to return a function declaration since the identifier is
not available.

That was already explained at
<http://groups.google.c om/group/comp.lang.javas cript/msg/81452faadf0019d 1>
- please read it carefully.

This way it shouldn't surprise you any more than
function foo() {}
var bar = foo;
alert(bar.toStr ing()) // that the name will be? foo of course

ECMAScript specs are not exactly wrong, but they are very confusingly
written: so confusingly actually that professional C++ programmers did
not get it right in application to this matter and they had to say
sorry latter (JScript team) though sorry should be ECMA's free-lancers.

In application to your routine two more issues has to be taken into
consideration:

1) var foo = function(){} creates anonymous function with toString
method returning "function(){... "
At the same time anonymous functions in event handlers (like one in
<body onload="") has toString method returning "function anonymous()
{...". The same is for function created by using Function()
constructor. It has nothing to do with some pragrammatical differences,
it was just preserved this way for legacy reasons. Brendan Eich once
had to explain it and say sorry on bugzilla.mozill a.org, later I'll
find the link again.
In any case you have to adjust the neuristic for both possible values
for anonymous functions.

2) toString method can be overloaded to prevent source code dump or to
be used for something completely else. It is rather easy fixable as
well but in such case it looks more like a reverse engineering so I
will not advise: but only point onto such possibility.

[RobG]

Peter Michaux wrote:

RobG wrote:

Peter Michaux wrote:

[...]

What I'm worried about is that he specs say the return value has the
form of a "function declaration". Does that mean the returned string
will definitely contain the name of the constructor function? Could it
instead return something like just "function () {}"?

A quick test shows that you can use an anonymous function as a
constructor, and it is returned in the form of a function declaration,
but it's actually a statement:

[...]

I tested the things you mentioned also. It seems the the return value
of toString() can take the form of a function statement when the
function is anonymous. So does this mean the ECMA specs are a little
bit wrong? If a function is anonymous, there is no way that toString
will be able to return a function declaration since the identifier is
not available.

I don't think the specification is wrong or contradictory, the wording
is:

"15.3.4.2 Function.protot ype.toString ( )
"An implementation-dependent representation of the function is
returned. This representation has the syntax of a
FunctionDeclara tion. Note in particular that the use and placement
of white space, line terminators, and semicolons within the
representation string is implementation-dependent."

The important part is "has the syntax of", it doesn't say "it is" a
function declaration. It is similar to the confusion caused by the
occasional use of "undefined" when "not defined" is meant.

The function is returned in a format that looks like a function
declaration, but since it's anonymous, there is no identifier or name.
The only solution to me is to put an identifier into function
statements, but that will only suit code you can control, not a general
case.

This may be an interesting exercise but using the constructor property
as the basis for program logic is unlikely to be reliable. Try
Douglas' suggestion: give your native function objects an explicit type
parameter.
--
Rob

[Michael Winter]

Peter Michaux wrote:

It seems the the return value of toString() can take the form of a
function statement when the function is anonymous. ...

That is precisely the form it /should/ take.

If a function is anonymous, there is no way that toString will be
able to return a function declaration since the identifier is not
available.

You seem to be overlooking the rather important initial sentence:

An implementation-dependent representation of the function is
returned.

An implementation is free to use whatever identifier it likes. An
obvious choice is "anonymous" , though anything (including a
randomly-generated identifier) will do.

Mike

[Peter Michaux]

RobG wrote:
<snip>

I don't think the specification is wrong or contradictory, the wording
is:

"15.3.4.2 Function.protot ype.toString ( )
"An implementation-dependent representation of the function is
returned. This representation has the syntax of a
FunctionDeclara tion. Note in particular that the use and placement
of white space, line terminators, and semicolons within the
representation string is implementation-dependent."

The important part is "has the syntax of", it doesn't say "it is" a
function declaration. It is similar to the confusion caused by the
occasional use of "undefined" when "not defined" is meant.

The function is returned in a format that looks like a function
declaration, but since it's anonymous, there is no identifier or name.
The only solution to me is to put an identifier into function
statements, but that will only suit code you can control, not a general
case.

At the beginning of section 13 of the specs it says

Syntax

FunctionDeclara tion:
function Identifier (FormalParamete rList_opt) { FunctionBody }

FunctionExpress ion:
function Identifier_opt (FormalParamete rList_opt) {FunctionBody}

Does the following sound reasonable? In the FunctionDeclara tion the
Identifier is not optional so a function declaration cannot be
anonymous. An anonymous function is always introduced through a
FunctionExpress sion.

Perhaps the section about toString() for a function should say that the
returned value has the syntax of a FunctionExpress ion. This would
account for anonymous functions.

This may be an interesting exercise

I think that is all it has become now.

but using the constructor property
as the basis for program logic is unlikely to be reliable.

Try Douglas' suggestion: give your native function objects an explicit type
parameter.

I think this is good advice.

Thanks Rob and Douglas.

Peter

[VK]

FunctionDeclara tion:

function Identifier (FormalParamete rList_opt) { FunctionBody }

FunctionExpress ion:
function Identifier_opt (FormalParamete rList_opt) {FunctionBody}

Does the following sound reasonable? In the FunctionDeclara tion the
Identifier is not optional so a function declaration cannot be
anonymous. An anonymous function is always introduced through a
FunctionExpress sion.

Did you try?
<script type="text/javascript">
function() {}
</script>

That is a perfectly valid syntax: but useless program-wise.
FunctionDeclara tion is not evaluated, so there is no "hook" left to use
this function in your program. This is all what they tried (but failed)
to say.

Perhaps the section about toString() for a function should say that the
returned value has the syntax of a FunctionExpress ion. This would
account for anonymous functions.

They couldn't say it in 1999, because already there was a great amount
of scripts using toString value from anonymous functions defined for
intrinsic handlers (see again my other post in this thread). I do agree
in advance that the chosen form for them:
"function anonymous() {..." is sub-optimal and semi-contadictory (if
function is called "anonymous" then it is called somehow and so it is
not anonymous). More logical would be do not use the word "anonymous"
at all as in the latter practice or at least use another order:
"anonymous function(){..."

But whatever was done - it was done, and we have to deal now with the
legacy outcomes.

[Richard Cornford]

VK wrote:
<snip>

Did you try?
<script type="text/javascript">
function() {}
</script>

That is a perfectly valid syntax:

No it is not. No ExpressionState ment may commence with the 'function'
keyword and the Identifier in a Function Declaration is not optional.

but useless program-wise. FunctionDeclara tion is not evaluated,
so there is no "hook" left to use this function in your program.
This is all what they tried (but failed) to say.

<snip>

Who are these "they" and why are they trying to be so incoherent?

Richard.