Calling the Javascript method without actually calling it

Sometimes we are just lazy. Especially when it comes to writing code. And although the parentheses in the function call do not lead to redundancy, sometimes they can still bore, especially when the javascript method does not need arguments passed to it. Sometimes it just bothers you.

Oddly enough, all this is not hard to do in Javascript, like most other methods that are called ... toString is probably one of many well-known, but also, like valueOf, which does more or less the same thing, but numerical (and some other types in JavaScript.

The easiest way to call it, including the plus sign:

+myFunction;

')
what actually means:

window.parseFloat(myFunction.valueOf());

So, all we need to do is to force the valueOf method to execute the function passed to it for execution:

Function.prototype.valueOf=function(){this.call(this); return 0;};

... and suddenly the plus sign becomes everything we need for this call.

Especially in OOP, you can have a lot of similar calls, but you can fix these methods so that they are called within the method itself:

Function.prototype.fix=function(s){var t=this; return function(){ return t.apply(s,arguments); }; };

Using this method in the constructor, you can make a wrapper:

var Foo= function (){
this .myMethod= this .myMethod.fix( this );
};


or automating a little:

var Foo= function (){
for ( var i in this )
if ( typeof ( this [i])== "function" )
this [i]= this [i].fix( this );
};

and finally, finish with a complete example (after a small OOP refactoring):

1. var StandardClass = function () {};
3. StandardClass.prototype.initMethods = function () {
4. for ( var i in this )
5. if ( typeof ( this [i]) == ” function ” && this [i] .dontWrap! == true )
6. this [i] = this [i] .fix ( this );
7. };
9. StandardClass.prototype.initMethods.dontWrap = true ;
11. Function.prototype.fix = function (s) {
12. var t = this ;
13. return function () {
14. return t.apply (s, arguments);
15. };
16. };
18. Function.prototype.valueOf = function () {
19. this .call ( this );
20. return 0;
21. };
23. var Foo = function (name) {
24. this .initMethods ();
25. this .name = name;
26. };
28. Foo.prototype = new StandardClass;
30. Foo.prototype.showName = function () {
31. alert ( this .name);
32. };
34. Foo.prototype.showNameUpperCase = function () {
35. alert ( this .name.toUpperCase ());
36. };
38. var myFoo = new Foo (“Hello World”);
40. + myFoo.showName;
41. + myFoo.showNameUpperCase;

* This source code was highlighted with Source Code Highlighter .