Cómo emular argumentos de palabra clave en las funciones de ActionScript 3

Question

Las funciones en Python se pueden llamar utilizando argumentos de palabra clave de la forma palabra clave = valor. Por ejemplo, la siguiente función:

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

podría ser llamado en cualquiera de las siguientes maneras:

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

ActionScript 3 no disponen de este servicio. ¿Cómo podría emularlo mejor?

Answer 1

Puede implementar algo similar utilizando la cantidad variable de argumentos para una función que se muestra here.

Answer 2

No va a lanzar cualquier error en tiempo de compilación si te equivocas, pero se podría hacer algo como esto:

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

Y luego, cuando se hace llamar así:

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

El {} corchetes crean un objeto en línea. Una versión de largo aliento del código anterior se puede escribir así:

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

Si usted le da una matriz en lugar:

awesomefunction([23, 99 ]); 

([] es la abreviatura de una matriz por cierto)

Los índices serán accesible de esta manera:

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

Así que para llevar todo TOG si puedes usar el hecho de que || operador devuelve el valor del objeto que primero se evalúa como verdadera, no sólo cierto que hacer:

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

Por lo tanto, la función anterior dará el mismo resultado para todos estos tres llamadas:

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

sin embargo, esto no permitirá que le permite mezclar nombre y un número, pero se puede hacer así:

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

no es muy bonito, pero funciona!

Answer 3

Hay un tipo especial en actionscript 3.0 llamado ... (resto). Coloque este tipo en la lista de parámetros para una función y luego esa función puede aceptar cualquier número de argumentos. El sintaxis correcto es: ... arrayName, donde arrayName es el nombre de la matriz que contendrá los argumentos.

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

Answer 4

La respuesta corta es que en ActionScript, el orden de los parámetros es parte de la firma de una función. Para evitar ese hecho, debes hacer un trabajo extra o dedicarte a malas prácticas de codificación que te morderán más adelante. Diría que tiene dos "buenas" opciones para obtener flexibilidad similar a lo que está buscando.La forma formal sería definir una clase de datos para que actúe como el parámetro de la función. Es decir:

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 situación es más ad-hoc, un enfoque menos formal es hacer uso libre de parámetros opcionales, y permitir que la persona que llama para pasar nula para cualquier parámetro no se arrastra quieren omitir. Esto se consigue la flexibilidad, pero se sacrifica un reparto justo de la limpieza:

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

Pero si estas dos opciones parecen difíciles de manejar, eso es porque lo son. A largo plazo, creo que en última instancia es mejor internalizar la idea de que las listas de parámetros ordenados forman parte de la gramática de Actionscript, y probablemente será mejor que no intentes evitarlas. Si lo hace, sacrifica la simplicidad (como se indicó anteriormente) o conduce a prácticas deficientes (como usar objetos no estructurados para parámetros, como se sugiere en otras respuestas, lo que sacrifica muchos beneficios de la comprobación de tipo y error).

La forma más equilibrada para trabajar con la gramática es simplemente utilizar parámetros opcionales siempre que sea posible, por lo tanto:

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

Usted todavía tiene que vivir con el hecho de que los parámetros única final se puede omitir, pero así es como el el lenguaje está hecho (y cómo se definen y usan sus métodos nativos).