Execute private function inside the class by its name (string)

Question

At the moment I have simple JavaScript class like this:

function MyClass() {

// ... some code ...

this.Create = function() {
  funcName = 'myTestFunc()';
  cTimer = setTimeout(funcName, 1000);
  }

// ... more code ...

var myTestFunc = function() {
  alert ('everything\'s OK!');
  }

// ... more code ...
}

and to test it I'm using this code:

x = new MyClass();
x.Create();

I have some troubles to execute this function by it's name. If I put just eval(funcName); instead of setTimeout call it works fine but can't figure out why it doesn't work this way.

Course, this is part of more complex code but rest of code is irrelevant to this problem.

My question is obvious - How to execute function by its name set as setTimeout function's argument? Is it possible?

Note: Making this function public (this.myTestFunc = ...) isn't an option!

Update:

funcName = "myTestFunc()"; is just an example. In real code it looks like funcName = getRandomEffectFunctionName();! It's just a random value.

Answer 1

Referring to the update:

Instead of setting:

 var funcName = "getRandomEffectFunctionNeme()";

Thus, setting a reference to the function's name you should do

 var funcRef = getRandomEffectFunctionNeme;

And set a reference to the function itself . Not only this avoids the issues setTimeout with strings has*. It also solves your closure issue since your code is structured in such a way the timeout has access to the function itself.

In your case, let's assume you have some functions that are filters, for example lowPass highPass and blur. In that case, instead of choosing a function name we would be choosing a function.

First, we store these functions in an array:

var filters = [lowPass,highPass,blur];

In JavaScript, functions are first-class objects, you can pass them around just like other objects.

Next, we'll get a random number

var chosen = Math.floor(Math.random()*3);//get a random number between 0 and 2

Finally, we'll choose the filter and invoke it

var filter = filters[chosen];
setTimeout(filter,1000);

( * just try debugging it, it basically invokes the compiler whenever ran and is painfully slow)

---

You just pass a function to setTimeout as a parameter, rather then a string, setTimeout(myTestFunc,1000) .

When calling Create it would have access to it anyway because they are in the same closure.

Answer 2

NOTE: This solution is only applicable if you can not pass the function name as a function reference, for example if you're integrating with code that is outside your control. Generally, when possible, you should pass a function reference since in JavaScript, all functions are objects.

Assuming that the timeout and the function are in the same closure your code is pretty close. The problem is that your eval call executes in the global context because it is in a timer. This means they are no longer in the same lexical scope.

You can however, grab a reference to the function by clever use of eval which you can later call in the setTimeout invocation.

var F=eval(funcName);// gain a reference to the function given the function's name
cTimer = setTimeout(F, 1000);

If you're using AIR or don't trust the functionName string you can do the following:

function Test(){
 var functionContainer={
  t:function(){
   console.log("it's t");
  }
 };
 this.callT=function(functionName){
  var F=functionContainer[functionName];
  console.log("F is:",F);
  setTimeout(F,500);
 }
}
(new Test()).call("t");

This is preferable since you are invoking setTimeout with a function's name and not a string. In general, using setTimeout with a string can have issues, it's hard to debug or maintain.