Parámetros de función -- Flash CS3

ActionScript 3.0 proporciona funcionalidad para los parámetros de función que puede resultar novedosa para los programadores que empiecen a estudiar el lenguaje. Aunque la idea de pasar parámetros por valor o por referencia debe resultar familiar a la mayor parte de los programadores, el objeto arguments y el parámetro ... (rest) serán nuevos para la mayoría.

Subtemas

Pasar argumentos por valor o por referencia

En muchos lenguajes de programación, es importante comprender la diferencia entre pasar argumentos por valor o por referencia; esta diferencia puede afectar a la manera de diseñar el código.

Al pasar por valor, el valor del argumento se copia en una variable local para usarlo en la función. Al pasar por referencia, sólo se pasa una referencia al argumento, en lugar del valor real. No se realiza ninguna copia del argumento real. En su lugar, se crea una referencia a la variable pasada como argumento y se asigna dicha referencia a una variable local para usarla en la función. Como una referencia a una variable externa a la función, la variable local proporciona la capacidad de cambiar el valor de la variable original.

En ActionScript 3.0, todos los argumentos se pasan por referencia, ya que todos los valores se almacenan como objetos. No obstante, los objetos que pertenecen a los tipos de datos simples, como Boolean, Number, int, uint y String, tienen operadores especiales que hacen que se comporten como si se pasaran por valor. Por ejemplo, el código siguiente crea una función denominada passPrimitives() que define dos parámetros denominados xParam y yParam, ambos de tipo int. Estos parámetros son similares a variables locales declaradas en el cuerpo de la función passPrimitives(). Cuando se llama a la función con los argumentos xValue e yValue, los parámetros xParam e yParam se inicializan con referencias a los objetos int representados por xValue e yValue. Como los argumentos son valores simples, se comportan como si se pasaran por valor. Aunque xParam e yParam sólo contienen inicialmente referencias a los objetos xValue e yValue, los cambios realizados a las variables en el cuerpo de la función generan nuevas copias de los valores en la memoria.

function passPrimitives(xParam:int, yParam:int):void
{
    xParam++;
    yParam++;
    trace(xParam, yParam);
}

var xValue:int = 10;
var yValue:int = 15;
trace(xValue, yValue);          // 10 15
passPrimitives(xValue, yValue); // 11 16
trace(xValue, yValue);          // 10 15

En la función passPrimitives(), los valores de xParam e yParam se incrementan, pero esto no afecta a los valores de xValue e yValue, como se indica en la última sentencia trace. Esto es así aunque se asigne a los parámetros los mismos nombres que a las variables, xValue e yValue, ya que dentro de la función xValue e yValue señalarían nuevas ubicaciones de la memoria que existen por separado de las variables externas a la función que tienen el mismo nombre.

Todos los demás objetos (es decir, los objetos que no pertenecen a los tipos de datos simples) se pasan siempre por referencia, ya que esto ofrece la capacidad de cambiar el valor de la variable original. Por ejemplo, el código siguiente crea un objeto denominado objVar con dos propiedades, x e y. El objeto se pasa como un argumento a la función passByRef(). Como el objeto no es un tipo simple, no sólo se pasa por referencia, sino que también se mantiene como una referencia. Esto significa que los cambios realizados en los parámetros dentro de la función afectarán a las propiedades del objeto fuera de la función.

function passByRef(objParam:Object):void
{
    objParam.x++;
    objParam.y++;
    trace(objParam.x, objParam.y);
}
var objVar:Object = {x:10, y:15};
trace(objVar.x, objVar.y); // 10 15
passByRef(objVar);         // 11 16
trace(objVar.x, objVar.y); // 11 16

El parámetro objParam hace referencia al mismo objeto que la variable objVar global. Como se puede ver en las sentencias trace del ejemplo, los cambios realizados en las propiedades x e y del objeto objParam se reflejan en el objeto objVar.

Valores predeterminados de los parámetros

En ActionScript 3.0 se incluye como novedad la capacidad de declarar valores predeterminados de parámetros para una función. Si una llamada a una función con valores predeterminados de parámetros omite un parámetro con valores predeterminados, se utiliza el valor especificado en la definición de la función para ese parámetro. Todos los parámetros con valores predeterminados deben colocarse al final de la lista de parámetros. Los valores asignados como valores predeterminados deben ser constantes de tiempo de compilación. La existencia de un valor predeterminado para un parámetro convierte de forma efectiva a ese parámetro en un parámetro opcional. Un parámetro sin un valor predeterminado se considera un parámetro requerido.

Por ejemplo, el código siguiente crea una función con tres parámetros, dos de los cuales tienen valores predeterminados. Cuando se llama a la función con un solo parámetro, se utilizan los valores predeterminados de los parámetros.

function defaultValues(x:int, y:int = 3, z:int = 5):void
{
    trace(x, y, z);
}
defaultValues(1); // 1 3 5

El objeto arguments

Cuando se pasan parámetros a una función, se puede utilizar el objeto arguments para acceder a información sobre los parámetros pasados a la función. Algunos aspectos importantes del objeto arguments son:

ActionScript 3.0 permite que las llamadas a funciones incluyan más parámetros que los definidos en la definición de la función, pero generará un error del compilador en modo estricto si el número de parámetros es menor que el número de parámetros requeridos. Se puede utilizar la matriz aspect del objeto arguments para acceder a cualquier parámetro pasado a la función, independientemente de si ese parámetro está definido en la definición de la función. En el ejemplo siguiente se utiliza la matriz arguments junto con la propiedad arguments.length para hacer un seguimiento de todos los parámetros pasados a la función traceArgArray():

function traceArgArray(x:int):void
{
    for (var i:uint = 0; i < arguments.length; i++)
    {
        trace(arguments[i]);
    }
}

traceArgArray(1, 2, 3);

// salida:
// 1
// 2
// 3

La propiedad arguments.callee se suele utilizar en funciones anónimas para crear recursión. Se puede utilizar para añadir flexibilidad al código. Si el nombre de una función recursiva cambia a lo largo del ciclo de desarrollo, no es necesario preocuparse de cambiar la llamada recursiva en el cuerpo de la función si se utiliza arguments.callee en lugar del nombre de la función. La propiedad arguments.callee se utiliza en la siguiente expresión de función para habilitar la recursión:

var factorial:Function = function (x:uint)
{
    if(x == 0)
    {
        return 1;
    }
    else
    {
        return (x * arguments.callee(x - 1));
    }
}

trace(factorial(5)); // 120

Si se utiliza el parámetro ... (rest) en la declaración de la función, el objeto arguments no estará disponible. Hay que acceder a los parámetros a través de los nombres de parámetro declarados.

También hay que procurar no utilizar la cadena "arguments" como nombre de parámetro, ya que ocultará el objeto arguments. Por ejemplo, si se vuelve a escribir la función traceArgArray() de forma que se añade un parámetro arguments, las referencias a arguments en el cuerpo de la función hacen referencia al parámetro, en lugar de al objeto arguments. El siguiente código no produce ningún resultado:

function traceArgArray(x:int, arguments:int):void
{
    for (var i:uint = 0; i < arguments.length; i++)
    {
        trace(arguments[i]);
    }
}

traceArgArray(1, 2, 3);

// ningún resultado

El objeto arguments de versiones anteriores de ActionScript también contenía una propiedad denominada caller, que es una referencia a la función que llamó a la función actual. La propiedad caller no existe en ActionScript 3.0, pero si se necesita una referencia a la función que llama, se puede modificar dicha función de forma que pase un parámetro adicional que sea una referencia sí mismo.

El parámetro ...(rest)

ActionScript 3.0 introduce una declaración de un parámetro nuevo que se llama ... (rest). Este parámetro permite especificar un parámetro de tipo matriz que acepta un número arbitrario de argumentos delimitados por comas. El parámetro puede tener cualquier nombre que no sea una palabra reservada. Este parámetro debe especificarse el último. El uso de este parámetro hace que el objeto arguments no esté disponible. Aunque el parámetro ... (rest) ofrece la misma funcionalidad que la matriz arguments y la propiedad arguments.length, no proporciona funcionalidad similar a la que ofrece arguments.callee. Hay que asegurarse de que no es necesario utilizar arguments.callee antes de utilizar el parámetro ... (rest).

En el ejemplo siguiente se reescribe la función traceArgArray() con el parámetro ... (rest) en lugar del objeto arguments:

function traceArgArray(... args):void
{
    for (var i:uint = 0; i < args.length; i++)
    {
        trace(args[i]);
    }
}

traceArgArray(1, 2, 3);

// salida:
// 1
// 2
// 3

El parámetro ... (rest) también puede utilizarse con otros parámetros, con tal de que sea el último parámetro de la lista. En el ejemplo siguiente se modifica la función traceArgArray() de forma que su primer parámetro, x, sea de tipo int y el segundo parámetro utilice el parámetro ... (rest). La salida omite el primer valor porque el primer parámetro ya no forma parte de la matriz creada por el parámetro ... (rest).

function traceArgArray(x: int, ... args)
{
    for (var i:uint = 0; i < args.length; i++)
    {
        trace(args[i]);
    }
}

traceArgArray(1, 2, 3);

// salida:
// 2
// 3