Comment émuler des arguments de mots-clés dans les fonctions ActionScript 3

Question

Les fonctions de Python peuvent être appelées à l'aide d'arguments de type mot clé = valeur. Par exemple, la fonction suivante:

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, "!" 

pourrait être appelé dans l'une des façons suivantes:

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

ActionScript 3 ne dispose pas de cette installation. Comment pourrais-je l'imiter au mieux?

Answer 1

Vous pouvez implémenter quelque chose de similaire en utilisant un nombre variable d'arguments pour une fonction affichée here.

Answer 2

Il ne lancera aucune erreur au moment de la compilation si vous gâcher mais vous pouvez faire quelque chose comme ceci:

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

Et puis en l'appelant à faire comme ceci:

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

Le {} les crochets créent un objet en ligne. Une version longue haleine du code ci-dessus peut être écrit comme ceci:

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

Si vous donnez un tableau à la place:

awesomefunction([23, 99 ]); 

([] est un raccourci pour un tableau BTW)

Les indices seront accesible comme ceci:

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

Alors pour tout mettre tog Si vous pouvez utiliser le fait que le || opérateur retourne la valeur de l'objet qui évalue d'abord à true, non seulement vrai à faire:

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); 
} 

Ainsi, la fonction ci-dessus donnera la même sortie pour ces trois appels:

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

cela cependant ne vous permettra pas de mélanger nommés et numérotés, mais vous pouvez le faire comme ceci:

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

ce n'est pas très jolie, mais ça marche!

Answer 3

Il existe un type spécial dans actionscript 3.0 appelé ... (reste). Mettez ce type dans la liste des paramètres pour une fonction, puis cette fonction peut accepter n'importe quel nombre d'arguments. Le sytanx approprié est: ... arrayName, où arrayName est le nom du tableau qui contiendra les arguments.

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

Answer 4

La réponse courte est que dans Actionscript, l'ordre des paramètres fait partie de la signature d'une fonction. Pour contourner ce problème, vous devez soit faire un travail supplémentaire, ou se livrer à de mauvaises pratiques de codage qui vous mordront plus tard. Je dirais que vous avez deux «bonnes» options pour obtenir une flexibilité semblable à celle que vous recherchez.Le moyen formel serait de définir une classe de données pour agir en tant que paramètre de la fonction. C'est:

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); 

Si la situation est plus, une approche moins formelle ad hoc est d'utiliser libérale des paramètres facultatifs, et permettre à l'appelant de passer null pour un paramètre non-fuite, ils veulent omettre. Cela vous obtient la flexibilité, mais vous sacrifiez un traitement équitable de la propreté:

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') 

Mais si ces deux options semblent difficiles à manier, c'est parce qu'ils sont. À long terme, je pense qu'il est préférable d'intérioriser l'idée que les listes de paramètres ordonnées font partie de la grammaire d'ActionScript, et vous êtes probablement mieux de ne pas essayer de les éviter. Cela sacrifie la simplicité (comme ci-dessus), ou conduit à de mauvaises pratiques (comme utiliser des objets non structurés pour les paramètres, comme suggéré dans d'autres réponses, ce qui sacrifie de nombreux avantages de vérification de type et d'erreur).

La façon la plus équilibrée de travailler avec la grammaire est tout simplement utiliser les paramètres facultatifs lorsque cela est possible, ainsi:

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') 

Il vous reste à vivre avec le fait que peuvent être omis des paramètres de suivi seulement, mais voilà comment la la langue est faite (et comment ses méthodes natives sont définies et utilisées).