How can I have one function call another function dynamically?

[Randell D.]

Folks,

I'm sure this can be done legally, and not thru tricks of the trade - I
hope someone can help.

I'm writing a 'tool' (a function) which can be used generically in any
of my projects. When it completes, it can call a success, or a failure
function. The names of these success, or failure functions will differ,
and I'd like to know how I can pass the name of a function to my tool,
and how my tool can call the function, using that name...

Roughly speaking I want to have something like

function my_engine(succe ss_function_nam e, failure_functio n_name)
{
// Processing code here chews data

// Then...
if(myResult==tr ue)
{ success_functio n_name(); }
else
{ failure_functio n_name(); }
}

Anybody got any ideas/suggestions? I'm sure there was a js method that
I could use but I can't find reference to it in my O'Reilly JavaScript
pocket reference...

All help, via the newsgroup (so all can learn) will be greatly appreciated,

Thanks,
Randell D.

[Robert]

VK wrote:

Are you saying it is not valid JavaScript?

*Roughly* that.

As such Function will be evaluated on each call, it's performance is
lower than with standard function(). So it's suggested to use it only
if you really need to create run-time functions from the scratch.

Yes, that is exactly what he asked for.
name -> function call
It could not have been done using a literal function to my knowledge.

Anyway,
eval(name+"()")
is a better solution.

[Robert]

Yann-Erwan Perio wrote:

Using "eval" as property accessing technique isn't really a good
practice, in the posted case the function is called from within a
function iself called directly, so something like
this[name]();
would be a better solution:-)

Ahh interesting. So many ways to achieve something in Javascript :)

[Robert]

Michael Winter wrote:

Anyway,
eval(name+"()")
is a better solution.

No, it isn't. Passing a function object reference is much better, as
David describes, and it's what the OP should use.

Yes, but that was not what he asked for.

[Michael Winter]

On 15/07/2005 12:37, Robert wrote:

Michael Winter wrote:

[...] Passing a function object reference is much better [...]

Yes, but that was not what he asked for.

He asked how to have one function call another. His current approach is
to pass the name of that function, but I don't see why that should be
set in stone, particularly if there's a better way.

Mike

--
Michael Winter
Prefix subject with [News] before replying by e-mail.

[Randy Webb]

Robert wrote:

VK wrote:

Are you saying it is not valid JavaScript?

*Roughly* that.

As such Function will be evaluated on each call, it's performance is
lower than with standard function(). So it's suggested to use it only
if you really need to create run-time functions from the scratch.

Yes, that is exactly what he asked for.
name -> function call
It could not have been done using a literal function to my knowledge.

Anyway,
eval(name+"()")
is a better solution.

NO.

window[name+'()']

is a better solution.

--
Randy
comp.lang.javas cript FAQ - http://jibbering.com/faq & newsgroup weekly

[Matt Kruse]

Randell D. wrote:

I'd like to know how I can pass the name of a
function to my tool, and how my tool can call the function, using that
name...

Wow, all these posts and no one answered your question :)

Passing a reference to a function is best, but not always possible or
practical.

Since functions are just properties of the window object, you can do:

function callfunc(name) {
if (typeof(window[name])=="function") {
window[name]();
}
}

--
Matt Kruse
http://www.JavascriptToolbox.com
http://www.AjaxToolbox.com

[Robert]

Matt Kruse wrote:

Randell D. wrote:

I'd like to know how I can pass the name of a
function to my tool, and how my tool can call the function, using that
name...

Wow, all these posts and no one answered your question :)

That's not fair! I answered... just wasn't a very efficient way to do it :p

[Yann-Erwan Perio]

Randy Webb wrote:

window[name+'()']

is a better solution.

I'm now reluctant to submit window[]-based solutions, for at least two
reasons:
- window[] implies that the host is a browser; using "this" would work
on all browsers, provided the function is called as a member of the
global object,
- window[] implies that the conception relies on global functions, which
generally indicates a namespace pollution, therefore often a lazy
conception.

Anyway, in your example you have to put the parentheses outside of the
identifier, otherwise this won't work.

The following should help the OP into misunderstandin g everything:-)

---
window["foo()"]=foo;
function foo(){alert("He llo, World!")};
function test(name){
this[name+"()"]();
}

test("foo");
---
Cheers,
Yep.

[Matt Kruse]

Yann-Erwan Perio wrote:

- window[] implies that the host is a browser; using "this" would work
on all browsers, provided the function is called as a member of the
global object,
Using 'this' is highly sensitive to the calling environment also. For most
situations, referencing window[name]() will work while this[name]() might
not.
- window[] implies that the conception relies on global functions,
which generally indicates a namespace pollution, therefore often a
lazy conception.

I disagree.

Most people developing javascript are not experts at the language by any
means. Most code does not make use of closures or inner functions, but
instead has a bunch of global functions.

--
Matt Kruse
http://www.JavascriptToolbox.com
http://www.AjaxToolbox.com

[Yann-Erwan Perio]

Matt Kruse wrote:

Hi,

- window[] implies that the host is a browser; using "this" would work
on all browsers, provided the function is called as a member of the
global object,

Using 'this' is highly sensitive to the calling environment also. For most
situations, referencing window[name]() will work while this[name]() might
not.
As you say, the "this" value depends on the way the function is called:
if called as a method, then the "this" value will be the reference of
the object of which it is the method, if called as a function then the
"this" value will be a reference to the global object.

So if you want a function generic enough to be called as a member of
different objects (global object, custom object), and only operate with
the global object for the "this" value, then indeed referencing "window"
directly would be a good option (while I'd prefer, personally, use a
construct with an inner function returning the global object).

However I feel that, when calling a function, the "this" value inside
should be already known and should not depend on how the function is
called (an external parameter of the function, lack of encapsulation).
- window[] implies that the conception relies on global functions,
which generally indicates a namespace pollution, therefore often a
lazy conception.

I disagree.

Most people developing javascript are not experts at the language by any
means. Most code does not make use of closures or inner functions, but
instead has a bunch of global functions.

Your argument, AIUI, is strange you know; you say you disagree that
global functions indicate a lazy conception, and then you justify the
point by precising that the guys using the "global functions" approaches
are not javascript experts.

What should I conclude from this? Should I trust so-called professionals
who can only use global functions, and don't even understand the
paradigm of the language they're using, to be skilled enough to provide
me with quality code?

Or would you rather defend that conceptions based on global functions
can be as good as conceptions using the javascript paradigm to its full?
Regards,
Yep.