JavaScript: Find out if function is anonymous or is defined in a object

Question

I'm trying to write a helper method in JavaScript. It should act differently if one sends in a function or an reference to a function.

I want to like to use it like this:

helper('div', function () { return false; })
helper('div', obj.fn)

What I can't figure out is: how to inside the helper function tell the difference between the two?

I think it's due to that JavaScript first evaluates the obj.fn before it sends it in. The only workaround I found is to send the obj.fn as an obj, i.e.

helper('div', { fn: obj.fn })

Then I can tell the difference between the two with typeof. But I really like some way to make it without the extra object declaration.

Answer 1

UPDATED *(AGAIN): I thought that the toString() method might be your only way forward here. It doesn't however treat a reference of an anonymous object differently.

This code demonstrates that:

function acceptparam(fn){

      console.log("fn.constructor = " + fn.constructor);
      console.log("typeof fn = " + typeof fn);
      console.log("fn toString " + fn.toString());

      console.log("fn.prototype = " + fn.prototype);
      console.log("fn.prototype.constructor = " + fn.prototype.constructor);
      console.log("this[0] = " + this[0]);
      console.log("---");

     }

     function empty(){
      return ;
     }

     var x = {
      y : function(){return;}
     }

     acceptparam(empty);
     acceptparam(function(){return;});
     acceptparam(x.y);

Very interesting question, without implementing your own solution I dont think you can do it, this post helps to explain why. Its about the parent child relationship only being one way.

http://codingforums.com/showthread.php?t=134855

Answer 2

You can use toString() to find out if the function is anonymous assuming it is declared as a named function and not an unnamed function assigned to a variable:

See updated code below for an improved regex for IE

function jim () { var h = "hello"; }
function jeff(func) 
{ 
    var fName;
    var inFunc = func.toString();
    var rExp   = /^function ([^\s]+) \(\)/;
    if (fName = inFunc.match(rExp))
       fName = fName[1];

    alert(fName);
}

Will give you the name of the function if any.

jeff(function () { blah(); }); // alert: null;
jeff(function joe () { blah(); }); // alert: "joe";
jeff(jack); // "jack" if jack is function jack () { }, null if jack = function() {}

EDIT Lewis clarified the question for me and his answer is correct to the extent that functions declared as object properties are unnamed, but this answer does state that only named functions work and you can still declare an object property via a named function:

var jim = { };
function jeff(func) 
{ 
    var fName;
    var inFunc = func.toString();
    var rExp   = /^function ([^\s(]+)\s?\(\)/;
    if (fName = inFunc.match(rExp))
       fName = fName[1];

    window.prompt(fName, inFunc);
}
(function () { function jim.jack () {} })();
jeff(jim.jack);

The downside to this is that named functions that are properties of objects must be within a child function of the current scope because named functions are set at parse time as opposed to unnamed functions which are set at execution time:

var jim = {};
function jim.jack () {} // error
(function () { function jim.jack () {} })(); // no error

Answer 3

I thought I'd add another alternative answer, mainly because I didn't want to add to the soup that is my other answer but also because it didn't go down to well with the stackoverflow voters that don't leave constructive comments ;-)

As an alternative to what you're trying to do, you could add a third parameter to the helper function:

function helper (tagName, fn, method)
{
    if (method)
        fn = fn[method];

    //- Do rest of helper function here
}
//- Now if we pass an object method to helper function we can identify it properly
helper('div', obj, "fn"); // method is obj.fn
helper('div', function () { blah(); }); // Still works fine

Merely a suggestion and works as well as or even better than your current work-around.