When is a function not a function?

[David Mark]

I've got a collection of functions that accept a function or object
(paired with a method name) as a callback.

For the longest time I have relied on this test.

(typeof cb == 'function')

This should work as well, but I am not sure how well it degrades in
older browsers. I think there are issues with functions created in
another context (eg frame) as well.

(cb instanceof Function)

Then I came across this.

(!!fn && typeof fn != "string" && !fn.nodeName && fn.constructor !=
Array && /function/i.test( fn + "" ))

I'm sure it is wrong as it is from jQuery, but it makes me wonder if
there are bugs in older browsers that will mislead my test.

As an aside, I was looking at the jQuery source as some browser
sniffer I was arguing with on a blog cited it as part of an "everybody
is doing it" argument. I had glanced at it previously and dismissed
it based on its resemblance to Prototype. Upon closer inspection, it
makes Prototype look inspired. Suffice to say that anybody who
recommends it hasn't read the code. It's a horror show.

[Randy Webb]

Thomas 'PointedEars' Lahn said the following on 10/14/2007 2:00 PM:

Randy Webb wrote:

>Richard Cornford said the following on 10/14/2007 11:18 AM:

>>Randy Webb wrote:
Richard Cornford said the following on 10/13/2007 10:28 PM:
<dh******** **@gmail.comwro te:
>typeof fn? nope, not in safari.
Are you certain? Is it really the case that objects that
return 'function' from a typeof operation cannot be
called? Or are you just not expecting them to be callable?
Have you actually tried calling the objects that safari
asserts are functions?
Can I ask you to first define what you mean by "called"
or "callable"?
No more than sticking an ArgumentsList after a reference to the object
(the 'call operator', with or without arguments). That is what I would
consider calling an object, and to be callable that abject should not
throw an exception as a direct result of its being called (though it may
still throw an exception in response to its arguments'' values, as that
would be behaviour passed the point of calling it and so unrelated to
its callability).

That would imply, to me anyway, that Safari (even in Beta form) gets it
right and all other browsers I tested it on get it wrong. Would that be
a correct assumption?

Not at all. With host objects, all bets are off. And as long as objects
that can't be called do not yield `function' or `object', there is no problem.

Is there any thing in scripting that isn't an Object though? That part
is confusing to me. I thought any and everything was an Object, at least
underneath, and that functions were merely augmented Objects. That
implies to me that anything and everything should return object or some
subset of object.

>>>All other Windows based browsers I have report it as 'object'.
Maybe, but that is neither necessarily true of windows based browsers
nor historically common on Mac browsers. Even Mac IE 5 would report
'function' in this context, and on Windows you only have to go back a
few Opera versions to see the same there.

Then Safari is right and IE/FF/Opera are wrong?

It is not a matter of right and wrong.

Thank you.

--
Randy
Chance Favors The Prepared Mind
comp.lang.javas cript FAQ - http://jibbering.com/faq/index.html
Javascript Best Practices - http://www.JavascriptToolbox.com/bestpractices/

[Richard Cornford]

Randy Webb wrote:

Richard Cornford said the following on 10/14/2007 11:18 AM:

>Randy Webb wrote:

<snip>

>>Can I ask you to first define what you mean by "called"
or "callable"?

No more than sticking an ArgumentsList after a reference to
the object (the 'call operator', with or without arguments).
That is what I would consider calling an object, and to be
callable that abject should not throw an exception as a direct
result of its being called (though it may still throw an
exception in response to its arguments'' values, as that would be
behaviour passed the point of calling it and so
unrelated to its callability).

That would imply, to me anyway, that Safari (even in Beta form)
gets it right

It is more a matter of what safari is doing is not in any way incorrect.
It could do much else instead and still not be doing anything incorrect.
Generally I am inclined to think that when at object can be called it
makes perfect sense for - typeof - to report 'function', even if with
host objects there is nothing to say that they should.

and all other browsers I tested it on get it wrong.

They are not getting it wrong, as there is nothing to define what would
qualify as 'correct' in this context. Some of those browsers are doing
something that is a little irrational in having a callable object but
reporting 'object' with - typeof -, but they either are Windows IE or
are imitating Windows IE in some of its more irrational behaviour.

Remember that on Windows IE all the DOM methods, and functions such as
alert and setTimeout also report 'object' from - typeof -, so it is at
least consistently irrational.

Would that be a correct assumption?

There are no grounds for expecting any particular outcome so there are
no criteria for correct or incorrect.

<snip>

>>All other Windows based browsers I have report it as

'object'.

Maybe, but that is neither necessarily true of windows based
browsers nor historically common on Mac browsers. Even Mac
IE 5 would report 'function' in this context, and on Windows
you only have to go back a few Opera versions to see the same
there.

Then Safari is right and IE/FF/Opera are wrong?

<snip>

On firefox (and all previous Mozilla/gecko browsers) you could not call
the collection objects, so reporting 'object' from - tyepof - is a
rational action. Windows IE is just doing the same as it always has
done, and Opera has recently changed to imitate the behaviour of Windows
IE (previously it did report 'function'). I don't approve of that change
but I can understand why it has happened.

Richard.

[Thomas 'PointedEars' Lahn]

Thomas 'PointedEars' Lahn wrote:

Randy Webb wrote:

>and that functions were merely augmented Objects.

Functions/methods are special objects that can be called and inherit from
Object.prototyp e.

D'oh. Make that Function.protot ype.

[David Mark]

On Oct 14, 11:18 am, "Richard Cornford" <Rich...@litote s.demon.co.uk>
wrote:
[snip]

>
This is the dojo function:-

| if(dojo.isBrows er && dojo.isSafari){
| // only slow this down w/ gratuitious casting in Safari since
| // it's what's b0rken
| dojo.isFunction = function(/*anything*/ it){
| if((typeof(it) == "function") && (it == "[object NodeList]")){
| return false;
| }
| return (typeof it == "function" || it instanceof Function);
| }
| }else{
| dojo.isFunction = function(/*anything*/ it){
| return (typeof it == "function" || it instanceof Function);
| }
| }

It is useful to note that Dojo (along with jQuery) was cited as an
example of a "major library" that implements browser sniffing, in a
misguided attempt to justify browser sniffing as a viable technique.

Clearly the author(s) have assumed that Safari is the only agent that
is "b0rken" in this way (and that their isSafari method is a reliable
indication of a Safari browser.) As noted, the forks that follow
raise questions about what this code is supposed to do. It also casts
serious doubt about the veracity of functions built atop it.

So the browser sniffer who cited this mess as an example is justifying
his own incompetence by comparing it to other peoples' less-than-
competent output. The fact that lots of developers use these
libraries is cited as proof that they are a worthwhile comparison.
The "argument" is circular as users of jQuery, Dojo, Prototype, etc.
know only what they hear from the "experts" who churn out the
libraries. The "experts" conclude that since so many less-than-expert
developers listen to them, they must be on the right track. Tell
either side they are wrong and they cite the other.

[Richard Cornford]

Matt Kruse wrote:

On Oct 14, 9:18 am, Richard Cornford wrote:

>Fist you must state what it is that defined 'a function'. One
completely rational and justifiable definition of 'a function'
in ECMAScritp terms could be "an object that can be called"

Bringing this thread back from the dead...

Is there a way to reliably check whether I can call an object
as a function?

Not if you want to include methods of host objects in the set of objects that could be called.
You might reasonably say that if - typeof x - was 'function' then it would be safe to call the
object, and be correct in all the environments that I have ever encountered. But we both know
that would mean never calling host methods on Windows IE, which would be somewhat disappointing.

<snip>

I know the argument can be made that this is bad design
to not know whether or not you're passing in something
that can be called as a function.

Absolutely.

But I'm asking as a purely technical question, whether or
not it's possible.

Not possible in the general case. Possibly a case fro try-catch and handling the errors. Or
avoid the problem by designing the issue out of the system.

Richard.

[VK]

On Dec 1, 6:24 pm, VK <schools_r...@y ahoo.comwrote:

1) Report the bug at bugzilla.mozill a.org

No need to do it:

https://bugzilla.mozilla.org/show_bug.cgi?id=296858
and
https://bugzilla.mozilla.org/show_bug.cgi?id=346789
as dups of
https://bugzilla.mozilla.org/show_bug.cgi?id=268945
"Applet tag returns function instead of object with typeof JavaScript
method".

Still a reference to bug ID would be helpful so side readers could
know if one looking for a particular bug workaround or with some
universal JS/DOM feature.

[VK]

On Dec 1, 9:03 pm, Matt Kruse <m...@mattkruse .comwrote:

else if ( ('ActiveXObject ' in window) &&

This is and always has been a terrible way to infer anything.
Use conditional compilation instead, which will only run in the
JScript engine where the "problems" exist.

Unless someone will implement a browser with conditional compilation
and IE spoofing. :-))

Taking into account the OTC deal of browser producers ("spoof whatever
you need but ActiveXObject") this property check is very reliable as
well - again on condition that someone is trying to use your program
and not to get a runtime error. There is no protection for a
determined user of the latter kind - but he/she never was a subject of
my preoccupations. Within the same OTC deal for IE/Gecko branches it
is pretty secure to:
if ('ActiveXObject ' in window) {
// IE branch
}
else if ('GeckoActiveXO bject' in window) {
// Gecko block
}
else if ('opera' in window) {
// Opera block
}
else {
// some lesser-minor UA
}

Again: no offence of any kind to the conditional compilation instead.

((''+obj).index Of('function')! =-1) ) {
return 'function';
}

This is way to broad. An object like
{ description:'Th is lets you test for a function'}
would be labeled a 'function' by your $typeof function.

Are you sure about it? ;-) Do not mix an object property value with
toString of the object itself.

[VK]

On Dec 1, 9:31 pm, VK <schools_r...@y ahoo.comwrote:

((''+obj).index Of('function')! =-1) ) {
return 'function';
}

This is way to broad. An object like
{ description:'Th is lets you test for a function'}
would be labeled a 'function' by your $typeof function.

Are you sure about it? ;-) Do not mix an object property value with
toString of the object itself.

What is bad in this block is that it will make unnecessary checks for
JScript objects where typeof always works just fine. Because in IE DOM
model DOM objects have nothing to do with JScript objects the
suggested optimization could be:

else if (('ActiveXObjec t' in window) &&
(!Object.protot ype.isPrototype Of(obj)) &&
((''+obj).index Of('function')! =-1)) {
return 'function';
}

[VK]

On Dec 2, 12:14 pm, VK <schools_r...@y ahoo.comwrote:

// # Because the problem affects only DOM elements
// # and because DOM elements are strictly separate
// # from JScript objects in IE then to secure ourselves
// # from overloaded toString and from unnecessary checks:

return Object.prototyp e.isPrototypeOf (o) ?
typeof o : /^function/.test(o);
}
}

Oops... The function always returns true/false, not typeof results:

return Object.prototyp e.isPrototypeOf (o) ?
(typeof o == 'function') : /^function/.test(o);

[Matt Kruse]

On Dec 2, 3:14 am, VK <schools_r...@y ahoo.comwrote:

return Object.prototyp e.isPrototypeOf (o) ?
...
func += "if (RegExp.prototy pe.isPrototypeO f(o))"+

Fails across windows, yes?

Matt Kruse