Fundamentos de la utilización de funciones -- Flash CS3

En esta sección se ofrece una definición básica de función y se describen las técnicas de invocación.

Subtemas

Invocación de funciones

Para llamar a una función se utiliza su identificador seguido del operador paréntesis (()). Se puede utilizar el operador paréntesis para escribir los parámetros de función que se desea enviar a la función. Por ejemplo, la función trace(), que es una función de nivel superior de la API de Flash Player se usa por todo el manual:

trace("Use trace to help debug your script");

Si se llama a una función sin parámetros, hay que utilizar un par de paréntesis vacíos. Por ejemplo, se puede utilizar el método Math.random(), que no admite parámetros, para generar un número aleatorio:

var randomNum:Number = Math.random();

Funciones definidas por el usuario

Hay dos maneras de definir una función en ActionScript 3.0: se puede utilizar una sentencia de función o una expresión de función. La técnica que se elija dependerá de si se prefiere un estilo de programación más estático o más dinámico. Si se prefiere la programación estática, o en modo estricto, se deben definir las funciones con sentencias de función. Las funciones deben definirse con expresiones de función si existe la necesidad específica de hacerlo. Las expresiones de función se suelen usar en programación dinámica (en modo estándar).

Sentencias de función

Las sentencias de función son la técnica preferida para definir funciones en modo estricto. Una sentencia de función empieza con la palabra clave function, seguida de:

Por ejemplo, el código siguiente crea una función que define un parámetro y después invoca la función con la cadena "hello" como valor del parámetro:

function traceParameter(aParam:String)
{
    trace(aParam);
}

traceParameter("hello"); // hello

Expresiones de función

La segunda manera de declarar una función es utilizar una sentencia de asignación con una expresión de función (también se suele llamar literal de función o función anónima). Éste es un método que requiere escribir más y que se usaba mucho en versiones anteriores de ActionScript.

Una sentencia de asignación con una expresión de función empieza por la palabra clave var, seguida de:

Por ejemplo, el código siguiente declara la función traceParameter mediante una expresión de función:

var traceParameter:Function = function (aParam:String)
{
    trace(aParam);
};
traceParameter("hello"); // hello

Tenga en cuenta que, a diferencia de lo que ocurre en una sentencia de función, no se especifica un nombre de función. Otra diferencia importante entre las expresiones de función y las sentencias de función es que una expresión de función es una expresión, no una sentencia. Esto significa que una expresión de función no es independiente, como una sentencia de función. Una expresión de función sólo se puede utilizar como una parte de una sentencia (normalmente una sentencia de asignación). En el siguiente ejemplo se muestra la asignación de una expresión de función a un elemento de matriz:

var traceArray:Array = new Array();
traceArray[0] = function (aParam:String)
{
    trace(aParam);
};
traceArray[0]("hello");

Criterios para elegir entre sentencias y expresiones

Como regla general, se debe utilizar una sentencia de función a menos que circunstancias específicas requieran una expresión. Las sentencias de función son menos detalladas y proporcionan una experiencia más uniforme entre el modo estricto y el modo estándar que las expresiones de función.

También son más fáciles de leer que las sentencias de asignación que contienen expresiones de función. Por otra parte, las sentencias de función hacen que el código sea más conciso; son menos confusas que las expresiones de función, que requieren utilizar las palabras clave var y function.

Además, proporcionan una experiencia más uniforme entre los dos modos de compilador, ya que permiten utilizar la sintaxis con punto en modo estándar y en modo estricto para invocar un método declarado con una sentencia de función. Esto no es así necesariamente para los métodos declarados con una expresión de función. Por ejemplo, el código siguiente define una clase denominada Example con dos métodos: methodExpression(), que se declara con una expresión de función, y methodStatement(), que se declara con una sentencia de función. En modo estricto no se puede utilizar la sintaxis con punto para invocar el método methodExpression().

class Example
{
  var methodExpression = function() {}
  function methodStatement() {}
}

var myEx:Example = new Example();
myEx.methodExpression(); // error en modo estricto; funciona correctamente en modo estándar
myEx.methodStatement(); // funciona correctamente en modo estricto y en modo estándar

Las expresiones de función se consideran más apropiadas para la programación centrada en el comportamiento dinámico (en tiempo de ejecución). Si se prefiere utilizar el modo estricto, pero también hay que llamar a un método declarado con una expresión de función, se puede utilizar cualquiera de las dos técnicas. En primer lugar, se puede llamar al método utilizando corchetes ([]) el lugar del operador punto (.). La siguiente llamada a método funciona correctamente tanto en modo estricto como en modo estándar:

myExample["methodLiteral"]();

En segundo lugar, se puede declarar toda la clase como una clase dinámica. Aunque esto permite llamar al método con el operador punto, la desventaja es que se sacrifica parte de la funcionalidad en modo estricto para todas las instancias de la clase. Por ejemplo, el compilador no genera un error si se intenta acceder a una propiedad no definida en una instancia de una clase dinámica.

Hay algunas circunstancias en las que las expresiones de función son útiles. Las expresiones de función se suelen utilizar para crear funciones que se utilizan una sola vez y después se descartan. Otro uso menos común es asociar una función a una propiedad de prototipo. Para más información, consulte El objeto prototipo.

Hay dos diferencias sutiles entre las sentencias de función y las expresiones de función que se deben tener en cuenta al elegir la técnica que se va a utilizar. La primera diferencia es que las expresiones de función no existen de forma independiente como objetos con respecto a la administración de la memoria y la eliminación de datos innecesarios. Es decir, cuando se asigna una expresión de función a otro objeto, como un elemento de matriz o una propiedad de objeto, se crea la única referencia a esa expresión de función en el código. Si la matriz o el objeto al que la expresión de función está asociada se salen del ámbito o deja de estar disponible, se dejará de tener acceso a la expresión de función. Si se elimina la matriz o el objeto, la memoria utilizada por la expresión de función quedará disponible para la eliminación de datos innecesarios, lo que significa que se podrá recuperar esa memoria y reutilizarla para otros propósitos.

En el siguiente ejemplo se muestra que, para una expresión de función, cuando se elimina la propiedad a la que está asignada la expresión, la función deja de estar disponible. La clase Test es dinámica, lo que significa que se puede añadir una propiedad denominada functionExp que contendrá una expresión de función. Se puede llamar a la función functionExp() con el operador punto, pero cuando se elimina la propiedad functionExp, la función deja de ser accesible.

dynamic class Test {}
var myTest:Test = new Test();

// expresión de función 
myTest.functionExp = function () { trace("Function expression") };
myTest.functionExp();   // Expresión de función
delete myTest.functionExp;
myTest.functionExp();   // error

Si, por otra parte, la función se define primero con una sentencia de función, existe como su propio objeto y seguirá existiendo incluso después de que se elimine la propiedad a la que está asociada. El operador delete sólo funciona en propiedades de objetos, por lo que incluso una llamada para eliminar la función stateFunc() no funciona.

dynamic class Test {}
var myTest:Test = new Test();

// sentencia de función
function stateFunc() { trace("Function statement") }
myTest.statement = stateFunc;
myTest.statement(); // Sentencia de función
delete myTest.statement;
delete stateFunc;   // sin efecto
stateFunc();        // Sentencia de función
myTest.statement(); // error

La segunda diferencia entre las sentencias de función y las expresiones de función es que las sentencias de función existen en todo el ámbito en que están definidas, incluso en sentencias que aparecen antes que la sentencia de función. En cambio, las expresiones de función sólo están definidas para las sentencias posteriores. Por ejemplo, el código siguiente llama correctamente a la función scopeTest() antes de que se defina:

statementTest(); // statementTest

function statementTest():void
{
    trace("statementTest");
}

Las expresiones de función no están disponibles antes de ser definidas, por lo que el código siguiente produce un error en tiempo de ejecución:

expressionTest(); // error en tiempo de ejecución

var expressionTest:Function = function ()
{
    trace("expressionTest");
}

Devolución de valores de funciones

Para devolver un valor de la función se debe utilizar la sentencia return seguida de la expresión o el valor literal que se desea devolver. Por ejemplo, el código siguiente devuelve una expresión que representa al parámetro:

function doubleNum(baseNum:int):int
{
    return (baseNum * 2);
}

Tenga en cuenta que la sentencia return finaliza la función, por lo que las sentencias que estén por debajo de una sentencia return no se ejecutarán, como se indica a continuación:

function doubleNum(baseNum:int):int {
    return (baseNum * 2);
    trace("after return"); // Esta sentencia trace no se ejecutará.
}

En modo estricto se debe devolver un valor del tipo apropiado si se elige especificar un tipo devuelto. Por ejemplo, el código siguiente genera un error en modo estricto porque no devuelve un valor válido:

function doubleNum(baseNum:int):int
{
    trace("after return");
}

Funciones anidadas

Es posible anidar funciones, lo que significa que pueden declararse funciones dentro de otras funciones. Una función anidada sólo está disponible dentro de su función principal, a menos que se pase una referencia a la función a código externo. Por ejemplo, el código siguiente declara dos funciones anidadas dentro de la función getNameAndVersion():

function getNameAndVersion():String
{
    function getVersion():String
    {
        return "9";
    }
    function getProductName():String
    {
        return "Flash Player";
    }
    return (getProductName() + " " + getVersion());
}
trace(getNameAndVersion()); // Flash Player 9

Cuando se pasan funciones anidadas a código externo, se pasan como cierres de función, lo que significa que la función retiene todas las definiciones que hubiera en el ámbito cuando se definió la función. Para más información, consulte Cierres de función.