Getting a reference to the currently executing function object

Discussion in 'Javascript' started by reycri@gmail.com, Dec 4, 2006.

  1. Guest

    Hi,

    I need to be able to do this:

    var func = new Function("var me = <selfRef>; alert(me.params);");
    func.params = "This is a test parameter";
    window.setTimeout(func, 500);

    Basically, I need to add properties to a function object and access
    them within the function when it is executing. Therefore, I need to be
    able to replace <selfRef> in the above example with an expression that
    would resolve to the reference to the executing function object.
    Note that another use I have for this is when setting the
    onreadystatechange property of the XMLHttpRequest object to a function
    reference.

    I found one way that would work:

    function whoAmI()
    {
    return whoAmI.caller;
    }

    Then, replace <selfRef> above with whoAmI(). However, this seems a bit
    hacky to me and may not be the most efficient. Also, I have read that
    the caller property has been deprecated and may not work in all
    browsers.
    I am trying to avoid using closures as they are complicated and
    non-intuitive for most developers and can cause memory leaks in
    browsers if not used properly
    (http://www.jibbering.com/faq/faq_notes/closures.html).

    Any ideas?
     
    , Dec 4, 2006
    #1
    1. Advertising

  2. mick white Guest

    David Golightly wrote:

    [snip]
    > function Funk() { this.params = {}; }
    >
    > Funk.prototype.setParam = function(key, value) {
    > this.params[param] = value;
    > }
    >


    Close...

    Funk.prototype.setParam = function(key, value) {
    this.params[key] = value;
    }

    Mick

    > var f = new Funk;
    > f.setParam('monkeys', 23);
    > f.setParam('fruit', 'grapes');
    > for (var p in f.params) { alert(p + ':' + f.params[p]); }
    >
     
    mick white, Dec 4, 2006
    #2
    1. Advertising

  3. David Golightly wrote:
    > wrote:

    <snip>
    >> var func = new Function("var me = <selfRef>; alert(me.params);");
    >> func.params = "This is a test parameter";
    >> window.setTimeout(func, 500);

    <snip>
    > 1. Do not use "new Function('<function code>')" when you
    > know all the details of a function before runtime.


    This is not a reasonable statement as it disregards the possibility that
    the desired outcome may be multiple unique function objects created in a
    way that avoided the creation of closures.

    > This has all the drawbacks of using eval:


    Not by any means. It may have many of the drawbacks of - eval - but
    using the Function constructor does not result in the direct execution
    of its string argument, and also allows some control over the
    environment in which the string of code used is executed (the
    potentially independent provision of formal parameters for the function
    and the mixing of that string with other code that may, for example,
    mask out sensitive aspects of the global environment).

    > it's hugely inefficient.


    That very much depends on the environment. In IE6 the use of the
    Function constructor can be the fastest method of creating a function
    object (which is significant for people writing for an IE only context
    and needing performance.

    > I'm disappointed to see that the
    > CLJ FAQ still has a lot of code examples using "new Function"
    > when the function constructor
    >
    > var func = function(args) { /* code */ }
    > or
    > function func(args) { /* code */ }
    >
    > is preferred.

    <snip>

    Preferred by whom, and why? The code for those FAQ entries originate at
    a time when inner functions were not well supported (as they were not
    formally specified until ECMA 262 3rd Edition.). That makes them old but
    they have not stopped working (or being less well supported) in the
    meanwhile. Previous discussions on the subject have never exposed any
    technical justification for changing them, just vague personal
    pretences. While switching to using inner functions means forming
    closures, and so in many cases having to write additional code to
    mitigate IE's memory leak problem.

    Blanket injunctions without justification are very dangerous things.
    They tend to leave some people doing things without understanding why
    they are doing them. As with most things, what should be 'preferred' is
    a good technical understanding of how javascript behaves. That allows
    people to make informed design decisions about what is appropriate in
    their specific context.

    Richard.
     
    Richard Cornford, Dec 9, 2006
    #3
  4. VK Guest

    wrote:
    > var func = new Function("var me = <selfRef>; alert(me.params);");
    > func.params = "This is a test parameter";
    > window.setTimeout(func, 500);
    >
    > Basically, I need to add properties to a function object and access
    > them within the function when it is executing. Therefore, I need to be
    > able to replace <selfRef> in the above example with an expression that
    > would resolve to the reference to the executing function object.
    > Note that another use I have for this is when setting the
    > onreadystatechange property of the XMLHttpRequest object to a function
    > reference.
    >
    > I found one way that would work:
    >
    > function whoAmI()
    > {
    > return whoAmI.caller;
    > }
    >From this point I've got a bit confused of your actual: if "executing

    function object" then why "caller" ? (unless a typo instead of "callee"
    ?)

    Basically there can be two basic tasks:

    1) The function is called as a method of an object instance and you
    want a reference to that instance.

    2) You want a reference to the executing function within the function
    itself.

    ////////////

    1) ... (ask if it was the case)

    2) arguments.callee holds the needed reference. Within the "VK's
    Augmentation" :)) messing with strings forming the function body may
    get really... messy. This way I prefer to have a conventional function
    to edit and toString method overloaded to use with Function
    constructor:


    <script type="text/javascript">

    function F(arg) {
    var func = new Function(F.f);
    func.params = 'Test';
    window.setTimeout(func, 500);
    }

    /* Edit body as you used to */
    F.f = function() {
    window.alert(arguments.callee['params']);
    }
    /* Function constructor pickup start */
    F.f.$tS = F.f.toString;
    F.f.toString = function() {
    var b = F.f.$tS();
    return b.substring(b.indexOf('{')+1, b.lastIndexOf('}')-1);
    }
    /* Function constructor pickup end */

    function init() {
    F();
    }

    window.onload = init;
    </script>


    What I like is an ability to reference static member or clone it with
    the same object:

    function F(arg) {
    // clone for individual use:
    var func = new Function(F.f);

    // shared static:
    var func = F.f;
    }
     
    VK, Dec 9, 2006
    #4
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Chris Newby

    Access to currently executing Page object

    Chris Newby, Apr 19, 2005, in forum: ASP .Net
    Replies:
    2
    Views:
    348
    Matt Berther
    Apr 19, 2005
  2. Stefan
    Replies:
    2
    Views:
    613
    Brock Allen
    Jul 26, 2005
  3. Jeff Gaynor
    Replies:
    3
    Views:
    2,409
  4. visionset
    Replies:
    4
    Views:
    966
    Tor Iver Wilhelmsen
    Apr 13, 2007
  5. Dr. Phillip M. Feldman

    How to find number of line that is currently executing?

    Dr. Phillip M. Feldman, Oct 10, 2009, in forum: Python
    Replies:
    1
    Views:
    315
    ryles
    Oct 10, 2009
Loading...

Share This Page