Call a javascript function that's a member of an object by name

Question

I want to be able to pass a reference to an arbitrary function by name to another javascript function. If it's just a global function, there is no problem:

function runFunction(funcName) {
   window[funcName]();
}

But suppose the function could be a member of an arbitrary object, eg:

object.property.somefunction = function() {
 //
}

runFunction("object.property.somefunction") does not work. I know I can do this:

window["object"]["property"]["somefunction"]()

So while could write code to parse a string and figure out the heirarchy this way, that seems like work :) So I wondered if there's any better way to go about this, other than using eval()

Answer 1

You can call funcName.split('.') and loop through the resulting array, like this:

function runFunction(funcName) {
    var parts = funcName.split('.');
    var obj = window;

    for (var i = 0; i < parts.length; i++)
        obj = obj[parts[i]];

    return obj();
}

Answer 2

Nope -- other than using eval I do not know another way of walking down an object tree in JavaScript than to build a walker -- fortunately, it is easy to do:

/**
* Walks down an object tree following a provided path. 
* Throws an error if the path is invalid.
* 
* @argument obj {Object} The object to walk.
* @argument path {String} The path to walk down the provided object.
* @argument return_container {Boolean} Should walk return the last node *before* the tip 
* (i.e my_object.my_node.my_other_node.my_last_node.my_attribute)
* If `true` `my_last_node` will be returned, rather than the value for `my_attribute`.
* @returns {Mixed} Object or the value of the last attribute in the path.
*/
function walk_path(obj, path, return_container) {
    return_container = return_container || false;
    path = path_to_array(path, ".");
    var ln = path.length - 1, i = 0;
    while ( i < ln ) {
        if (typeof obj[path[i]] === 'undefined') {
            var err = new ReferenceError("The path " + path.join(".") + " failed at " + path[i] + ".");
            err.valid_path = path.slice(0,i);
            err.invalid_path = path.slice(i, ln+1);
            err.breaking_point = path[i];
            throw err;
        } else {
            var container = obj;
            obj = obj[path[i]];
            i++;
        }
    }
    // If we get down to the leaf node without errors let's return what was asked for.
    return return_container ? container : obj[path[i]];
};

/**
* path_to_array
*
* @argument path {string} A path in one of the following formats:
* `path/to/file`
* `path\\to\\file`
* `path.to.file`
* `path to file`
* @argument sep {string} optional A seperator for the path. (i.e. "/", ".", "---", etc.)
*
* If `sep` is not specified the function will use the first seperator it comes across as the path seperator.
* The precedence is "/" then "\\" then "." and defaults to " "
*
* returns {Array} An array of each of the elements in the string ["path", "to", "file"]
*/
function path_to_array(path, sep) {
    path = is_string(path) ? path : path + "";
    sep = is_string(sep) ? sep : 
                path.indexOf("/") >= 0 ? "/" : 
                path.indexOf("\\") >= 0 ? "\\" : 
                path.indexOf(".") >= 0 ? "." : " ";
    /* Alternately use SLak's
    sep = is_string(sep) ? sep : /[ \\/.]/;
    if you want simpler code that will split on *any* of the
    delimiters by default. */
    return path.split(sep);
}

function is_string(s) { return typeof s === "string"; }

Then just call it like so:

walk_path(my_object, "path.to.my.function")();

Answer 3

As far as possible avoid using eval() when you have a choice.

In your case you can split the param based on '.' and then construct your

window["object"]["property"]["somefunction"]()