So emulieren Sie Schlüsselwortargumente in ActionScript 3-Funktionen

Question

Funktionen in Python können mit Schlüsselwortargumenten der Form Schlüsselwort = Wert aufgerufen werden. Zum Beispiel die folgende Funktion:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'): 
    print "-- This parrot wouldn't", action, 
    print "if you put", voltage, "volts through it." 
    print "-- Lovely plumage, the", type 
    print "-- It's", state, "!" 

könnte in einer der folgenden Arten aufgerufen werden:

parrot(1000) 
    parrot(action = 'VOOOOOM', voltage = 1000000) 
    parrot('a thousand', state = 'pushing up the daisies') 
    parrot('a million', 'bereft of life', 'jump') 

Actionscript 3 nicht diese Möglichkeit hat. Wie würde ich es am besten nachmachen?

Answer 1

Sie könnten etwas Ähnliches implementieren, indem Sie eine variable Anzahl von Argumenten für eine gezeigte Funktion here verwenden.

Answer 2

Es wird keine Fehler bei der Kompilierung werfen, wenn Sie vermasseln, aber sie so etwas tun könnte:

public function awesomefunction(input:Object):void { 
    if (input.foo) trace("got foo"); 
    if (input.bar) trace("got bar"); 
} 

Und dann, wenn es so tut Aufruf:

awesomefunction({ foo : 23, bar : 99 }); 

Die {} Klammern erstellen ein Inline-Objekt. Eine lange umständliche Version des obigen Code kann wie folgt geschrieben werden:

var obj:Object = new Object(); 
obj.foo = 23; 
obj.bar = 99; 
awesomefunction(obj); 

Wenn Sie es ein Array geben statt:

awesomefunction([23, 99 ]); 

([] ist eine Abkürzung für ein Array btw)

Die Indizes werden wie folgt erreichbar sein:

public function awesomefunction(input:Object):void { 
    if (input[0]) trace("got foo"); 
    if (input[1]) trace("got bar"); 
} 

So ist es zu bringen alle tog Sie können jedoch die Tatsache, dass die || Operator den Wert des Objekts zurückgibt, die zuerst den Wert true, nicht nur wahr zu tun:

public function awesomefunction(input:Object):void { 
    var foo:int = input.foo || input[0]; 
    var bar:int = input.bar || input[1]; 
    if (foo) trace("got foo:", foo); 
    if (bar) trace("got bar:", bar); 
} 

also die obige Funktion wird die gleiche Leistung für alle diese drei Anrufe geben:

awesomefunction({ foo : 23, bar :55 }); 
awesomefunction({ bar : 55, foo : 23 }); 
awesomefunction([ 23, 55 ]); 

Dies wird jedoch nicht zulassen, dass Sie benannt und nummeriert zu mischen, aber Sie können wie folgt tun:

awesomefunction({ foo : 23, 1 : 55 }); 

es ist nicht sehr schön, aber es funktioniert!

Answer 3

In ActionScript 3.0 gibt es einen speziellen Typ namens ... (Rest). Setzen Sie diesen Typ in die Parameterliste für eine Funktion und diese Funktion kann dann eine beliebige Anzahl von Argumenten akzeptieren. Die richtige Syntax lautet: ... arrayName, wobei arrayName der Name des Arrays ist, das die Argumente enthält.

 
public function forYou(...args) : void{ 
    for(var i : int = 0; i

Answer 4

Die kurze Antwort ist, dass in Actionscript, die Reihenfolge der Parameter ist Teil einer Funktion Unterschrift ist. Um diese Tatsache zu umgehen, müssen Sie entweder zusätzliche Arbeit verrichten oder sich schlechten Programmierpraktiken hingeben, die Sie später beißen werden. Ich würde sagen, Sie haben zwei "gute" Optionen, um die Flexibilität zu erhalten, die Sie suchen.Der formale Weg wäre, eine Datenklasse zu definieren, die als Parameter der Funktion dient. Das heißt:

public class ComplaintData { 
    public var state:String = "a stiff"; 
    public var action:String = "voom"; 
    public var type:String = "Norwegian Blue"; 
    public var voltage:String; 

    public function ComplaintData(v:String) { 
     voltage = v; 
    } 
} 

// somewhere else.... 

function parrot(cd:ComplaintData) { 
    trace "-- This parrot wouldn't " + cd.action; 
    // etc. 
} 

var cd:ComplaintData = new ComplaintData("a million"); 
cd.action = "jump"; 
parrot(cd); 

Wenn die Situation ist mehr ad-hoc, eine weniger formale Ansatz ist zügigen Einsatz von optionalen Parameter zu machen, und lassen Sie den Anrufer null passieren für jeden Nicht-Hinter Parameter sie wollen wegzulassen. Diese bekommt man die Flexibilität, aber Sie eine angemessene Menge an Sauberkeit opfern:

function parrot(voltage:String, 
       state:String=null, 
       action:String=null, 
       type:String=null) { 
    if (state==null) { state = 'a stiff'; } 
    if (action==null) { action = 'voom'; } 
    if (type==null) { type = 'Norwegian Blue'; } 
    // .... 
} 
parrot('1000') 
parrot('1000000', null, 'jump') 

Aber wenn diese beiden Optionen unhandlich erscheinen, das ist, weil sie sind. Auf lange Sicht denke ich, dass es letztendlich am besten ist, die Idee zu verinnerlichen, dass geordnete Parameterlisten Teil der Actionscript-Grammatik sind, und es ist wahrscheinlich besser, sie nicht zu vermeiden. Dies opfert entweder Einfachheit (wie oben) oder führt zu schlechten Praktiken (wie die Verwendung unstrukturierter Objekte für Parameter, wie in anderen Antworten vorgeschlagen, was viele Vorteile der Typ- und Fehlerprüfung opfert).

Die ausgewogene Art und Weise mit der Grammatik zu arbeiten, ist verwenden Sie einfach optionale Parameter, wann immer möglich, also:

function parrot(voltage:String, 
       state:String='a stiff', 
       action:String='voom', 
       type:String='Norwegian Blue') { 
    // ... 
} 
parrot('1000'); 
parrot('1000000', 'pushing up the daisies'); 
parrot('a million', 'bereft of life', 'jump') 

Sie noch mit der Tatsache leben müssen, dass nur Hinter Parameter weggelassen werden kann, aber das ist, wie die Sprache wird gemacht (und wie ihre nativen Methoden definiert und verwendet werden).