Question

I’m pretty new to ActionScript, but not new to either object oriented or procedural languages in general. ActionScript’s particular combination of features from both categories, however, confuses me.

Specifically, I’m confused about the mechanism of ExternalInterface.addCallback(). The method signature is:

public static function addCallback(functionName:String, closure:Function):void

Of particular interest is the closure parameter, which has the following documentation:

closure:Function — The function closure to invoke. This could be a free-standing
function, or it could be a method closure referencing a method of an
object instance. By passing a method closure, you can direct the
callback at a method of a particular object instance.

I take the above to mean that closure only be a function (not a method), which may or may not be a closure containing a method call from an instantiated object. So I get confused when I see code like this (taken from the same documentation page):

public class ext_test extends Sprite {
    function ext_test():void {
        ExternalInterface.marshallExceptions = true;
        ExternalInterface.addCallback("g", g);

        try {
        ExternalInterface.call("throwit");
        } catch(e:Error) {
        trace(e)
        }
    }
    function g() { throw new Error("exception from actionscript!!!!") }
    }

The above code inserts in to addCallback, a non-static method of ext_test without wrapping it in a closure containing an instantiated ex_test object.

The method contains trivial code, but what if it were to have statements containing member variables and the like? How would the method be evaluated when it has no parent object?

Furthermore, (since the addCallback seems to allow the passing of arbitrary methods) the documentation makes no mention on the effect access modifiers have on the passed methods, if any. If I label a method private, am I still able to pass it to addCallback? What’s the deal?

I’d appreciate it if anyone can help me wrap my head around this.

Answer 1

If your concern is to know in what context the method you passed will be executed, this is simply the context in which you attached it.

The doc’s jibber jabber simply means that there are several kinds of function in AS3 and the runtime. “Free-standing” function refers to what you usually call an anonymous function – that still preserves the context in which they were defined :

var anonymous:Function = createAnonymous();
trace(anonymous()); // 123

function createAnonymous():Function {
    var internalStuff:Number = 123;
    var func:Function = function():Number {
        return internalStuff;
    }
    return func;
}

Methods closures are instances of your classes’ methods, the same way objects are instances of these classes. So, when you pass a method closure to ExternalInterface.addCallback(), you’ll be safe about the context (i.e. member variables) when it will be invoked.