ActionScript 3 language specification states:
In ECMA-262 edition 3, when this appears in a nested function, it is bound to the global object if the function is called lexically, without an explicit receiver object. In ActionScript 3.0, this is bound to the innermost nested this when the function is called lexically.
(Source: http://help.adobe.com/livedocs/specs/actionscript/3/wwhelp/wwhimpl/js/html/wwhelp.htm)
However I tried the following and my result is not what I expected from the sentence above - the this inside the nested function is bound to the global object:
function f():void
{
trace("f() this.a", this.a); // "ok"
function g():void { trace("g() this.a", this.a); } // "undefined"
g();
}
f.call( { a: "ok" } );
Either the documentation is wrong here or I didn't understand it correctly. Can you explain me?
I believe the case is the reference to the Object, not the nested function concept.
If you try:
function f(target:Object):void
{
trace("f() this.a", target.a); // "ok"
function g():void { trace("g() this.a", target.a); } // "ok"
g();
}
f( { a: "ok" } );
Related
I'm new to dart (coming from a python background), and I'm struggling to make a function work. I've created the following function:
void main() {
int number = 22;
Function evenChecker(int number) {
if ((number%2) == 0) {
print('$number is even');
} else {
print('$number is odd');
}
}
}
but is get the following error:
Error: A non-null value must be returned since the return type 'Function' doesn't allow null.
bin/hello_dart_project.dart:4
- 'Function' is from 'dart:core'.
Additionally, if anyone has any suggestions about a good dart learning resource, I'd highly appreciate the advice.
^
Unlike Python or JavaScript, there is no keyword to define functions in dart. Instead, we declare functions by starting with their return type:
void evenChecker(...) {...}
^^^^
// This is the return type. "void" means "returns the value null" or "doesn't return anything"
How do you check if an Object passed into a function is the one you are expecting?
public function writeRecord(grid:IExtendedDataGrid, record:Object):String
{
ExternalInferface.call("alert","record " + record);
if (record.contains("HotListItem")
{
//# I have found my object
}
else
{
//# Wrong type of object
}
}
When I display my object to the ExternalInterface alert call it displays the following...
record [object HotListItem]
I would like to be able to test for this type of Object beforehand.
Using the is operator has resolved my question.
I tried the instanceof operator but this was flagged as deprecated.
Thanks to Organis
if (record is HotListItem)
For example, take this code:
func jediTrainer () -> ((String, Int) -> String) {
func train(name: String, times: Int) -> (String) {
return "\(name) has been trained in the Force \(times) times"
}
return train
}
let train = jediTrainer()
train("Obi Wan", 3)
I am completely confused as to what is going on in this function. jediTrainer takes no parameters, and returns a function called train. When we say "train = jediTrainer()" are we now storing the FUNCTION "train" into the variable called "train", as it returned that function that's now stored in the variable? Can you please break down what exactly is going on here into steps? Thank you so much!
In Swift functions are first class objects that means functions can be referenced by variables, passed as parameters and returned from other functions.
In your case jediTrainer() returns a function which is a nested function in itself. So let train is referring to train() function in jediTrainer. Now you could call that train function using train variable.
For more information on this please refer to Function Types and related topics here.
You also have an opinion of definining functions inside a bodies of other functions.These are called nested function .
By default Nested functions is hidden from outside world .It can still be called and used by its enclosing function .An enclosing function can also return one of nested functions ,thus allowing the nested function to be used in another scope .
func aFunc (flag:Book)->(Int)->Int
{
func plus ( input:Int )->Int
{
return input + 1
}
func minus ( input:Int )->Int
{
return input - 1
}
if (flag)
{
return plus
}
else
{
return minus
}
}
To make public API of SWF more reliable, I usually wrap callbacks in closure with try/catch block:
private function addCallback(functionName:String, closure:Function):void {
ExternalInterface.addCallback(functionName, wrapEventHandler(closure));
}
private function wrapEventHandler(closure:Function):Function {
var self:Main = this;
return function(...arguments):* {
try {
return closure.apply(self, arguments);
} catch (error:Error) {
// Print error report here
}
}
}
When exception occurs in 'closure', error report will be printed.
I noticed that it works fine even when using 'null' instead of 'self':
closure.apply(null, arguments);
Is it safe to use 'null' in this case?
Callback I register with ExternalInterface aren't static functions; they use Main's class fields.
It works just fine with null, NaN and self. I couldn't find any problems with using NaN/null.
Passing the this argument to apply() is optional, and the parameter default value is NaN.
Parameters
thisArg:* (default = NaN) — The object to which the function is
applied.
Likewise with, call():
You can pass the value null for the thisObject parameter to invoke a
function as a regular function and not as a method of an object.
For example, the following function invocations are equivalent:
Math.sin(Math.PI / 4)
Math.sin.call(null, Math.PI / 4)
I have 2 classes representing 2 objects. From the "whoCalledMe" function, I want to find out what object called the function (without passing that information in as an argument). I've used a make-believe property, "caller", that would give me the reference I'm looking for. Is there a generic way I can get a reference to the caller from there?
package {
public class ObjectCallingTheFunction {
public var IDENTITY:String = "I'm the calling function!";
public function ObjectCallingTheFunction() {
var objectWithFunction:ObjectWithFunction = new ObjectWithFunction();
objectWithFunction.whoCalledMe();
}
}
}
package {
public class ObjectWithFunction {
public function whoCalledMe ():void {
trace(caller.IDENTITY); // Outputs: "I'm the calling function!"
}
}
}
It would help to know why you need this, because I have a feeling that you don't really. If the method is anonymous, you can bind the 'this' keyword by using .apply on the method:
var foo:Function = function(arg:int):void
{
trace(this);
};
var bar:Object = {
toString: function():String { return "bar"; }
};
var baz:Object = {
toString: function():String { return "baz"; }
};
foo.apply(bar); // <-- Prints "bar"
foo.apply(baz); // <-- Prints "baz"
If the method is an instance method method however, it's a bound method and thus "this" will always point to the instance of the class it's declared in, no matter if you redefine it by using the apply method. If it's a static method, "this" doesn't make sense and the compiler will catch it.
Other than that, there's really no way short of declaring it as a parameter. There used to be a caller property on the arguments object, but it was deprecated when AS3 was released. You can get a reference to the function itself through arguments.callee, but that's not really what you asked for.
In AS3 you can throw an error and then parse the Stack Trace to find out detailed informations.
You can check here for an example:
http://www.actionscript-flash-guru.com/blog/18-parse-file-package-function-name-from-stack-trace-in-actionscript-as3
If you want to find the called function's name you can follow this example:
http://www.flashontherocks.com/2010/03/12/getting-function-name-in-actionscript-3/
I guess you want to know the caller in debug purpose. if so I would recommend setting a breakpoint in the method/function instead of tracing. When the code breaks you can backtrace the caller and a lot more. Works in Flash IDE as well as Flashbuilder. Google "as3 breakpoints" if you are new to breakpoints.
Here is the official Adobe article on using arguments.callee
http://livedocs.adobe.com/flash/9.0/ActionScriptLangRefV3/arguments.html
It includes sample code.
Hope this helps.