how to compare two static functions in javascript equal or not equal?
I think you mean `String(f1) === String(f2)` unless you have a custom `string()` method that I'm unaware of :)
Andy E
2009-12-20 21:30:50
Another way of writing it, for the byte-savers out there: `""+f1 === ""+f2`
Andy E
2009-12-20 21:32:38
+3
A:
var f1 = f2 = function( a ){ return a; };
here, you can use f1 === f2 because they're pointing to the same memory and they're the same type
var f1 = function( a ){ return a; },
f2 = function( a ){ return a; };
here you can use that byte-saver Andy E used (which is implicitly converting the function to it's body's text as a String),
''+f1 == ''+f2.
this is the gist of what is happening behind the scences:
f1.toString( ) == f2.toString( )
Dan Beam
2009-12-20 21:52:52
haha, but it is your answer ...I just don't know how much JavaScript black magic the author has done (like we have) before, :P
Dan Beam
2009-12-20 22:17:57
Note that `var f1 = f2 = function(){ ... }` results in `f2` becoming a global property, due to undeclared assignment of function to `f2`. Undeclared assignments are generally harmful, so it's better to avoid that pattern. Also, don't rely on `Function.prototype.toString` — it's not standardized and varies across browsers.
kangax
2009-12-20 22:48:45
I just tested the above code in IE 6, 7, 8, FF 2, 3.0, 3.5 (Windows / Linux), Opera 10 (Windows / Linux), Safari 4, and Chrome (Windows / Linux).Which browsers do you develop for exactly? Konqueror, haha?here's the code, someone prove me wrong `javascript:(function(){var f1=function(a){return a;},f2=function(a){return a;};alert(f1.toString());alert(f2.toString());alert(""+f1==""+f2);})();`
Dan Beam
2009-12-21 01:37:39
Here are few I stumbled upon — http://perfectionkills.com/those-tricky-functions/ , so not something I would rely on. YMMV, of course ;)
kangax
2009-12-21 03:29:59
you're only comparing them to eachother in *the same browser*, so how the functions look **across browsers** is not really that helpful, but I appreciate your time taken to compile that list and will remember these flaws.
Dan Beam
2009-12-21 03:38:36
But Blackberry, for example, always returns *same representation for any 2 different function*. Doesn't that prove this approach unreliable? I also remember cases of Opera mini doing similar thing. This all makes perfect sense in environments like mobile phone browsers, where there's a limited amount of memory available (and so keeping representation of functions is rather wasteful, especially that specs do not put any restrictions on what `Function.prototype.toString` returns ;))
kangax
2009-12-21 04:13:24
Then, yes, you are right kangax. If all functions look the same when their .toString( ) function is called on BlackBerry, you're right not to use it in your mobile app. Do you have a better solution, or just that it's not really possible?
Dan Beam
2009-12-21 04:40:53
I simply try to avoid design which would lead to using function decompilation. You can certainly decompile functions when working in closed environments (e.g. in intranet apps) or for debugging/profiling purposes (during development). Anything that's meant for public web is better left without it, and, as a result, have less chances of blowing up in some less-common environments.
kangax
2009-12-21 22:39:22
A:
Whenever I need to compare functions I make sure there is no scope ambiguity and use the same function object.
Say I have some a pair of library functions that take a callback as one of the parameters. For the sake of this example create1minuteCallback function will set a 1 minute timer and call the callback on each tick. kill1minuteCallback will turn off the callback and you must pass the same callback function as you did for create1minuteCallback.
function create1minuteCallback(callback){
//implementation
}
function kill1minuteCallback(callback){
//implementation
}
Quite clearly this will not work as the function we are passing is different on the second line:
create1minuteCallback(function(){alert("1 minute callback is called");});
kill1minuteCallback(function(){alert("1 minute callback is called");});
I normally do this:
function callbackFunc(){alert("1 minute callback is called");}
create1minuteCallback(callbackFunc);
kill1minuteCallback(callbackFunc);
Igor Zevaka
2009-12-21 01:41:21