kann eine ActionScript-Funktion ihren eigenen Namen herausfinden?

Question

folgenden gegeben

function A(b:Function) { } 

Wenn die Funktion A(), können wir der Name der Funktion übergeben wird, in als Parameter 'b' bestimmt werden? Unterscheidet sich die Antwort für AS2 und AS3?

Answer 1

Der Name? Nein, das kannst du nicht. Was Sie jedoch tun können, ist die Referenz zu testen. Etwas wie folgt aus:

function foo() 
{ 
} 

function bar() 
{ 
} 

function a(b : Function) 
{ 
    if(b == foo) 
    { 
     // b is the foo function. 
    } 
    else 
    if(b == bar) 
    { 
     // b is the bar function. 
    } 
} 

Answer 2

Suchen Sie nur für eine Referenz, so dass Sie die Funktion wieder nach anrufen kann? Wenn ja, versuchen Sie, die Funktion auf eine Variable als Referenz zu setzen. var lastFunktion: Funktion;

Wenn Sie nun auf die zuletzt ausgeführte Funktion verweisen müssen, können Sie dies tun, indem Sie lastFunction aufrufen.

Ich bin mir nicht sicher, was genau Sie versuchen zu tun, aber vielleicht kann das helfen.

Answer 3

Ich benutze folgendes:

private function getFunctionName(e:Error):String { 
    var stackTrace:String = e.getStackTrace();  // entire stack trace 
    var startIndex:int = stackTrace.indexOf("at ");// start of first line 
    var endIndex:int = stackTrace.indexOf("()"); // end of function name 
    return stackTrace.substring(startIndex + 3, endIndex); 
} 

Verbrauch:

private function on_applicationComplete(event:FlexEvent):void { 
    trace(getFunctionName(new Error()); 
} 

Ausgang: FlexAppName/on_applicationComplete()

Weitere Informationen über die Technik kann bei Alex-Seite:

http://blogs.adobe.com/aharui/2007/10/debugging_tricks.html

Answer 4

Ich weiß nicht, ob es hilft, aber kann einen Verweis auf den Aufrufer der Funktion erhalten, die arguments (soweit ich nur in ActionScript 3 weiß).

Answer 5

Heres eine einfache Implementierung

public function testFunction():void { 
     trace("this function name is " + FunctionUtils.getName()); //will output testFunction 
    } 

und in einer Datei namens FunctionUtils ich diese setzen ...

/** Gets the name of the function which is calling */ 
    public static function getName():String { 
     var error:Error = new Error(); 
     var stackTrace:String = error.getStackTrace();  // entire stack trace 
     var startIndex:int = stackTrace.indexOf("at ", stackTrace.indexOf("at ") + 1); //start of second line 
     var endIndex:int = stackTrace.indexOf("()", startIndex); // end of function name 

     var lastLine:String = stackTrace.substring(startIndex + 3, endIndex); 
     var functionSeperatorIndex:int = lastLine.indexOf('/'); 

     var functionName:String = lastLine.substring(functionSeperatorIndex + 1, lastLine.length); 

     return functionName; 
    } 

Answer 6

Ich habe die vorgeschlagenen Lösungen ausprobiert, aber ich lief in Schwierigkeiten mit alle von ihnen an bestimmten Punkten. Meistens wegen der Begrenzungen zu entweder festen oder dynamischen Mitgliedern. Ich habe etwas gearbeitet und beide Ansätze kombiniert. Wohlgemerkt, es funktioniert nur für öffentlich sichtbare Mitglieder - in allen anderen Fällen wird null zurückgegeben.

/** 
    * Returns the name of a function. The function must be <b>publicly</b> visible, 
    * otherwise nothing will be found and <code>null</code> returned.</br>Namespaces like 
    * <code>internal</code>, <code>protected</code>, <code>private</code>, etc. cannot 
    * be accessed by this method. 
    * 
    * @param f The function you want to get the name of. 
    * 
    * @return The name of the function or <code>null</code> if no match was found.</br> 
    *   In that case it is likely that the function is declared 
    *   in the <code>private</code> namespace. 
    **/ 
    public static function getFunctionName(f:Function):String 
    { 
     // get the object that contains the function (this of f) 
     var t:Object = getSavedThis(f); 

     // get all methods contained 
     var methods:XMLList = describeType(t)..method.@name; 

     for each (var m:String in methods) 
     { 
      // return the method name if the thisObject of f (t) 
      // has a property by that name 
      // that is not null (null = doesn't exist) and 
      // is strictly equal to the function we search the name of 
      if (t.hasOwnProperty(m) && t[m] != null && t[m] === f) return m;    
     } 
     // if we arrive here, we haven't found anything... 
     // maybe the function is declared in the private namespace? 
     return null;           
    } 

Answer 7

Argumente verwenden.Angerufenen mit toString() und match im Allgemeinen:

function foo(){return arguments.callee.toString().match(/\s\w+/).toString()} 

Referenzen

• arguments callee method

• Tracing Function Arguments