Perfect function forwarding

[Alexis Nikichine]

Hello,

Today, I have a function:

function f()
{
}
and am looking for a way of distinguishing, from inside f, whether it
has been called with new, or not.

function f()
{
if( ... )
return new forwardedFuncti on(...);
else
return forwardedFuncti on();
}

Iow, are we [[Call]]ed or [[Construct]]ed. Can't get around it...

Any help appreciated,

Alexis

--
Some domain is free

[Thomas 'PointedEars' Lahn]

Alexis Nikichine wrote:

--
Some domain is [...]

somedomain.fr is not. Yet.

<URL:http://www.interhack.n et/pubs/munging-harmful/>
PointedEars

[Rob Williscroft]

Alexis Nikichine wrote in news:43******** *************** @news.free.fr in
comp.lang.javas cript:

[snip]

and am looking for a way of distinguishing, from inside f, whether it
has been called with new, or not.

function f()
{
if( ... )
return new forwardedFuncti on(...);
else
return forwardedFuncti on();
}

Iow, are we [[Call]]ed or [[Construct]]ed. Can't get around it...

var GLOBAL = this;
function f()
{
alert( this === GLOBAL );
}

f();
new f();

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Thomas 'PointedEars' Lahn]

Rob Williscroft wrote:

Alexis Nikichine wrote [...]:

and am looking for a way of distinguishing, from inside f, whether it
has been called with new, or not.

function f()
{
if( ... )
return new forwardedFuncti on(...);
else
return forwardedFuncti on();
}

Iow, are we [[Call]]ed or [[Construct]]ed. Can't get around it...

var GLOBAL = this;
function f()
{
alert( this === GLOBAL );
}

f();
new f();

this == GLOBAL

should suffice. However, either test does not work for functions called
from non-global method context.
PointedEars

[Randy Webb]

Thomas 'PointedEars' Lahn said the following on 12/27/2005 1:27 PM:

Alexis Nikichine wrote:

--
Some domain is [...]

somedomain.fr is not. Yet.

<URL:http://www.interhack.n et/pubs/munging-harmful/>

Are you actually to the point in life where you have nothing better to
do than pedantically whine about a snippet in a signature?

It might not be so bad if you would reference a decent article instead
of an outdate worthless reference.

None of which is relevant or even remotely related to this thread and/or
this Newsgroup.

--
Randy
comp.lang.javas cript FAQ - http://jibbering.com/faq & newsgroup weekly
Javascript Best Practices - http://www.JavascriptToolbox.com/bestpractices/

[Lasse Reichstein Nielsen]

Alexis Nikichine <al************ **@somedomain.f r> writes:

Today, I have a function:

function f()
{
}
and am looking for a way of distinguishing, from inside f, whether it
has been called with new, or not.

Since the only difference visible inside f will be the value of the
"this" operator, this will have to be sufficient. It cannot be
completely safe, but unless someone is deliberatly trying to cheat, it
should be fairly safe. Javascript has no language based protection
against malicious code.

You could try checking whether the value of "this" could be a new
object created with "new f()". E.g., check
this.constructo r == f
or
this instanceof f

I can't see any way of ensuring that f.prototype is the first object
in the prototype chain, so the above can be tricked using, e.g.,

var fake = new f();
// fiddle with fake
f.call(fake); // can't see that fake is not a new object

Indeed, there shouldn't be a way to see it. The "new" operator creates
the object, but the call to "f" to initialize it afterwards is just a
normal function call (calling the [[Call]] method of the function).

/L
--
Lasse Reichstein Nielsen - lr*@hotpop.com
DHTML Death Colors: <URL:http://www.infimum.dk/HTML/rasterTriangleD OM.html>
'Faith without judgement merely degrades the spirit divine.'

[Alexis Nikichine]

Lasse Reichstein Nielsen wrote:

Since the only difference visible inside f will be the value of the
"this" operator, this will have to be sufficient. It cannot be
completely safe, but unless someone is deliberatly trying to cheat, it
should be fairly safe. Javascript has no language based protection
against malicious code.

You could try checking whether the value of "this" could be a new
object created with "new f()". E.g., check
this.constructo r == f
or
this instanceof f
Oh thanks, I finally settled on:

function f()
{
if( this.constructo r == f )
return new forwardedFuncti on();
else
forwardedFuncti on();
}

The good of it is that no object with f as a constructor will ever
escape that f, and that it breaks none of my code.
I can't see any way of ensuring that f.prototype is the first object
in the prototype chain, so the above can be tricked using, e.g.,

var fake = new f();
// fiddle with fake
f.call(fake); // can't see that fake is not a new object
So, is my f really fooled with this ?

Since fake.constructo r == forwardedFuncti on, which implies
fake.constructo r != f, I guess that forwardedFuncti on will be called,
and not newed. Unless I'm mistaken, of course.

The only "fiddling with fake" that I could find that messed things up
was to hack f construcotr property:

fake.constructo r = f;
f.call(fake); // Ok, gotcha !

And since in my case, f is actually an anonymous inner function, this
fiddling is not possible.

So finally, here is my definite function interceptor, and I claim it is
bullet-proof (but would be interested in being proved wrong):

// richard cornford's "constructWithA rgs":

var constructWithAr gs = (function(){
function Dummy(){ ; }
return (function(fun, args){
Dummy.prototype = fun.prototype;
var tmp = new Dummy;
fun.apply(tmp, args);
return tmp;
})
})();

// precondition: obj[memberFunction] must be a function
function intercept( obj, memberFunction )
{
obj[memberFunction] = function() {
alert( "BEFORE call to " + memberFunction) ;
try
{
if( constructor == arguments.calle e )
return constructWithAr guments( obj[memberFunction], arguments );
else
return obj[memberFunction].apply( this, arguments );
}
finally
{
alert("AFTER call to " + memberFunction) ;
}
}
}

Actually I could make up one bullet:

intercept( this, "Array" );
a = new Array();
alert( a.constructor == Array ); // false !!

but it's not the interceptor that breaks, but the interceptor that
breaks outside code.
Indeed, there shouldn't be a way to see it. The "new" operator creates
the object, but the call to "f" to initialize it afterwards is just a
normal function call (calling the [[Call]] method of the function).

Well, I was imaginating in the wrong direction: I was somehow looking
for a way to determine whether 'this' was a fresh, new and immaculate
object. Dreaming out loud, I suppose.

Cheers,

Alexis