passing a function name to another funtion

[Kevin Blount]

I have a system that I want to try, which requires me, from an aspx
page, to call a generic function to work perform one task, then i want
to call another function with the results of that task.

something like this:

in my aspx page:
<input type=button onClick="doFirs tFunction('seco ndFunctionName' );">

then in my .js file:

var functionToCall = '';

function doFirstFunction (functionName) {

functionToCall = functionName

// do the initial, common task
sResult = xmlHttp.respons eText

//now call the second function, passing sResult to it

}

Right now I'm using 'switch' and manually adding possible values for
'functionName' then directing manually, but I'd like to make
"doFirstFunctio n" self-maintaining, i.e. without having to update it if
I add more 'second' functions later.

I thought I could use

eval('functionT oCall('+sResult +')');

but this doesn't work so far.

any ideas?

[Thomas 'PointedEars' Lahn]

VK wrote:

Thomas 'PointedEars' Lahn wrote:

VK wrote:

> They are "accessible as named properties of the window object" (I hope
> that this diplomatic answer covers both IE and non IE situations wich
> are rather different).

It covers /only/ the _HTML environment_ in _known_ _graphical_
_Web browsers_, which is its major flaw.

The statement "window host object and Global object are the same"
covers only non-IE based browsers.

It covers exactly _no_ browser.
PointedEars

[VK]

Captain Dondo wrote:

How do I test for existence of
such an entity?

if(window["myFunction ']) window["myFunction "](a,b,c);

Within the conditional checks JavaScript resolves empty strings, 0,
null, undefined and NaN to false.

Non-empty strings, non-zero numbers and references of any kind are
resolved to true.

If property doesn't exist, you'll get undefined which is covered by the
list above. So the frequently used way is:

// undefined gets resolved to boolean false:
if (window["myFunction "]) { window["myFunction "](); }
else { alert("Function doesn't exists"; }

[Thomas 'PointedEars' Lahn]

VK wrote:

Captain Dondo wrote:

How do I test for existence of such an entity?

if(window["myFunction ']) window["myFunction "](a,b,c);
Within the conditional checks JavaScript resolves empty strings, 0,
null, undefined and NaN to false.

Evaluated, not resolved. And that goes for all ECMAScript implementations .
Non-empty strings, non-zero numbers and references of any kind are
resolved to true.
Evaluated, not resolved.
If property doesn't exist, you'll get undefined which is covered by the
list above. So the frequently used way is:
Probably used by /you/. Along with your other numerous failed attempts at
proper programming.
// undefined gets resolved to boolean false:
if (window["myFunction "]) { window["myFunction "](); }
else { alert("Function doesn't exists"; }

However, much better is:

// in global context
var _global = this;

// anywhere "after" the above
if (typeof _global["myFunction "] == "function")
{
_global["myFunction "]();
}
else
{
window.alert("F unction does not exist");
}

Under the provision that `myFunction' is declared globally.

And the bracket property accessor is not necessary at all
if you already know the identifier: _global.myFunct ion

If all the code is in global context, one can use `this'
explicitly and does not have to declare the `_global'
variable. And `typeof myFunction' would suffice then.
PointedEars

[Lasse Reichstein Nielsen]

Randy Webb <Hi************ @aol.com> writes:

VK said the following on 4/21/2006 4:22 PM:

<input type="button" onclick="firstF unction(secondF unction);">
....
function firstFunction(p tr) {
// do stuff
ptr();
}

ptr is undefined unless that is the name of the function.

ptr is a parameter (and therefore a local variable) of firstFunction.
It is declared in the context where it is used, and will have a value
if one is passed to firstFunction, as it appears from the usage
that one is.
It's not undefined, and it's independent of the name of the function
being passed.

This is the best way to pass functions to other functions: as values.
Passing their names and requireing an explicit lookup is much more
fragile, less readable, requires the passed function to be globally
availalbe, and is all together unnecessary if you have the function
available where you call the first function.

<input type="button" onclick="firstF unction('second Function');">

That is the only way to do it that you have mentioned. And the apos'
have to be on the initial function call.

That's the only way to pass a function's name, which was what to OP
asked for.
It's definitly not the only way to have one function call a second,
where which second function is called is controlled by a parameter of
the first, which perhaps was what to OP really wanted.

/L
--
Lasse Reichstein Nielsen - lr*@hotpop.com
DHTML Death Colors: <URL:http://www.infimum.dk/HTML/rasterTriangleD OM.html>
'Faith without judgement merely degrades the spirit divine.'

[Kevin Blount]

I finally got back around to this, and found that this solution worked
perfectly. Manty thanks VK

VK wrote:

Alternatively (if you prefer handle strings) all existing functions are
tunelled through the window object, so:

<input type="button" onclick="firstF unction('second Function');">
...
function firstFunction(s tr) {
// do stuff
window[str]();
}

[RobG]

Kevin Blount wrote:

I finally got back around to this, and found that this solution worked
perfectly. Manty thanks VK
Please don't top-post.

VK wrote:

Alternatively (if you prefer handle strings) all existing functions are
tunelled through the window object, so:

No, they aren't[1].

Functions may be accessed through a property of the global object where
they are declared in a global scope or the value of a global property is
assigned a reference to a function (e.g. using function expression).

In browsers, the window object is equivalent to the global object, but
not all user agents are browsers and not all have a window object.
1. What does 'tunelled' mean in a JavaScript context? The correct
spelling is 'tunneled', and when used in an IT or computing context
refers to the encapsulation of one network protocol inside another. It
is normally used to transport a network protocol across a network that
otherwise wouldn't support it. I don't see how that applies to
JavaScript at all.
--
Rob
Group FAQ: <URL:http://www.jibbering.c om/faq/>

[RobG]

RobG wrote:
[...]

1. What does 'tunelled' mean in a JavaScript context? The correct
spelling is 'tunneled'

'Tunneled' is the US spelling, 'tunnelled' is the English spelling
(Oxford dictionary).
--
Rob
Group FAQ: <URL:http://www.jibbering.c om/faq/>

[Kevin Blount]

Please don't top post? whatever man..