Concepts de fonction de base -- Flash CS3

Cette section décrit les techniques d'appel et de définition des fonctions de base.

Sous-rubriques

Appel de fonctions

Vous appelez une fonction en utilisant son identifiant suivi par l'opérateur parenthèses (()). Vous placez les paramètres de fonction que vous souhaitez envoyer à la fonction entre parenthèses à l'aide de l'opérateur parenthèses. Par exemple, la fonction trace() (qui est une fonction de niveau supérieur dans l'API de Flash Player) est utilisée dans ce manuel :

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

Si vous appelez une fonction sans paramètres, vous devez utiliser une paire de parenthèses vide. Par exemple, vous pouvez utiliser la méthode Math.random(), qui ne prend aucun paramètre, pour générer un nombre aléatoire :

var randomNum:Number = Math.random();

Définition de vos fonctions

Il existe deux façons de définir une fonction dans ActionScript 3.0 : avec une instruction de fonction ou une expression de fonction. La technique que vous choisissez dépend du style de programmation que vous préférez, plus statique ou dynamique. Définissez vos fonctions à l'aide d'instructions de fonction si vous préférez une programmation en mode strict, ou statique. Définissez vos fonctions à l'aide d'expressions de fonction si vous en avez vraiment besoin. Les expressions de fonction sont utilisées plus souvent dans la programmation en mode standard, ou dynamique.

Instructions de fonction

Les instructions de fonction représentent la technique privilégiée pour définir des fonctions en mode strict. Une instruction de fonction commence par le mot-clé function, suivi de :

Par exemple, le code suivant crée une fonction qui définit un paramètre puis invoque la fonction à l'aide de la chaîne "hello" comme valeur de paramètre :

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

traceParameter("hello"); // bonjour

Expressions de fonction

La deuxième façon de déclarer une fonction est d'utiliser une instruction d'affectation avec une expression de fonction, parfois appelée littéral de fonction ou fonction anonyme. Il s'agit d'une méthode plus détaillée largement utilisée dans les versions précédentes d'ActionScript.

Une instruction d'affectation avec une expression de fonction commence par le mot-clé var, suivi de :

Par exemple, le code suivant déclare la fonction traceParameter à l'aide d'une expression de fonction :

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

Vous remarquerez que vous ne spécifiez pas de nom de fonction, comme dans une instruction de fonction. Une autre différence importante entre les expressions de fonction et les instructions de fonction est qu'une expression de fonction est plus une expression qu'une instruction. Ceci signifie qu'une expression de fonction ne peut pas être utilisée seule, contrairement à une instruction de fonction. Une expression de fonction peut être utilisée uniquement en tant que partie d'une instruction, généralement une instruction d'affectation. L'exemple suivant représente une expression de fonction affectée à un élément de tableau :

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

Choix d'instructions ou d'expressions

En règle générale, utilisez une instruction de fonction, à moins que des circonstances spécifiques exigent l'utilisation d'une expression. Les instructions de fonction sont moins détaillées et fournissent une expérience plus cohérente entre le mode strict et le mode standard que les expressions de fonction.

Les instructions de fonction sont plus lisibles que les instructions d'affectation qui contiennent des expressions de fonction. Les instructions de fonction rendent votre code plus concis ; elles prêtent moins à confusion que les expressions de fonction, qui exigent l'utilisation des mots-clés var et function.

Les instructions de fonction fournissent une expérience plus cohérente entre les deux modes de compilateur car vous pouvez utiliser la syntaxe à point en mode strict et en mode standard pour appeler une méthode déclarée à l'aide d'une instruction de fonction. Ceci ne s'applique pas nécessairement aux méthodes déclarées avec une expression de fonction. Par exemple, le code suivant définit une classe appelée Example avec deux méthodes : methodExpression(), qui est déclarée avec une expression de fonction, et methodStatement(), qui est déclarée avec une instruction de fonction. En mode strict, vous ne pouvez pas utiliser la syntaxe à point pour invoquer la méthode methodExpression().

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

var myEx:Example = new Example();
myEx.methodExpression(); // erreur en mode strict ; okay en mode standard
myEx.methodStatement(); // okay en modes strict et standard

Les expressions de fonction sont plus adaptées à la programmation ciblée sur un comportement d'exécution ou dynamique. Si vous préférez utiliser le mode strict mais que vous souhaitez également appeler une méthode déclarée avec une expression de fonction, vous pouvez utiliser l'une des deux techniques. Premièrement, vous pouvez appeler la méthode à l'aide de l'opérateur crochets ([]) au lieu de l'opérateur point (.). L'appel de méthode suivant a lieu à la fois en mode strict et en mode standard :

myExample["methodLiteral"]();

Deuxièmement, vous pouvez déclarer la classe entière comme classe dynamique. Même si ceci vous permet d'appeler la méthode à l'aide de l'opérateur point, l'inconvénient est que vous sacrifiez une fonctionnalité de mode strict pour toutes les instances de cette classe. Par exemple, le compilateur ne génère pas d'erreur si vous tentez d'accéder à une propriété non définie sur une instance d'une classe dynamique.

Les expressions de fonction peuvent être utiles dans certains cas. Les expressions de fonction sont couramment utilisées pour des fonctions qui sont utilisées une seule fois. Elles peuvent être utilisées également pour associer une fonction à une propriété de prototype. Pour plus d'informations, voir L'objet prototype.

Il existe deux légères différences entre les instructions de fonction et les expressions de fonction à prendre en compte lorsque vous choisissez la technique à utiliser. La première différence réside dans le fait que les expressions de fonction n'existent pas indépendamment en tant qu'objets en ce qui concerne la gestion de la mémoire et le nettoyage. En d'autres termes, lorsque vous affectez une expression de fonction à un autre objet (un élément de tableau ou une propriété d'objet, par exemple) vous créez l'unique référence à cette expression de fonction dans votre code. Si le tableau ou l'objet auquel est associée l'expression de fonction n'est plus disponible, vous n'avez plus accès à l'expression de fonction. Si le tableau ou l'objet est supprimé, la mémoire que l'expression de fonction utilise peut être nettoyée, ce qui signifie que la mémoire peut être réutilisée à d'autres fins.

L'exemple suivant indique que pour une expression de fonction, la fonction n'est plus disponible une fois que la propriété à laquelle l'expression est affectée est supprimée. La classe Test est dynamique, ce qui signifie que vous pouvez ajouter une propriété appelée functionExp qui contient une expression de fonction. La fonction functionExp() peut être appelée avec l'opérateur point, mais une fois que la propriété functionExp est supprimée, la fonction n'est plus accessible.

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

// expression de fonction 
myTest.functionExp = function () { trace("Function expression") };
myTest.functionExp();   // expression de fonction
delete myTest.functionExp;
myTest.functionExp();   // erreur

Si, d'un autre côté, la fonction est d'abord définie avec une instruction de fonction, elle existe comme son propre objet et continue à exister, même une fois que vous avez supprimé la propriété à laquelle elle est associée. L'opérateur delete fonctionne uniquement sur les propriétés d'objets, donc même un appel à supprimer la fonction stateFunc() ne fonctionne pas.

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

// instruction de fonction
function stateFunc() { trace("Function statement") }
myTest.statement = stateFunc;
myTest.statement(); // Instruction de fonction
delete myTest.statement;
delete stateFunc;   // pas d'effet
stateFunc();        // Instruction de fonction
myTest.statement(); // erreur

La deuxième différence entre les instructions de fonction et les expressions de fonction réside dans le fait que les instructions de fonction existent dans le cadre dans lequel elles sont définies, notamment les instructions qui apparaissent avant l'instruction de fonction. Les expressions de fonction, en revanche, sont définies uniquement pour les instructions ultérieures. Par exemple, le code suivant appelle la fonction scopeTest() avant qu'elle soit définie :

statementTest(); // statementTest

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

Les expressions de fonction ne sont pas disponibles avant d'être définies. Par conséquent, le code suivant provoque une erreur d'exécution :

expressionTest(); // erreur d'exécution

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

Renvoi de valeurs des fonctions

Pour renvoyer une valeur de votre fonction, utilisez l'instruction return suivie de l'expression ou de la valeur littérale que vous souhaitez renvoyer. Par exemple, le code suivant renvoie une expression représentant le paramètre :

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

Vous remarquerez que l'instruction return termine la fonction, de façon à ce que les instructions sous une instruction return ne soient pas exécutées, comme suit :

function doubleNum(baseNum:int):int {
    return (baseNum * 2);
    trace("after return"); // Cette instruction trace n'est pas exécutée.
}

En mode strict, vous devez renvoyer une valeur du type approprié si vous choisissez de spécifier un type de renvoi. Par exemple, le code suivant génère une erreur en mode strict car il ne renvoie pas de valeur valide :

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

Fonctions imbriquées

Vous pouvez imbriquer des fonctions, ce qui signifie que vous pouvez déclarer des fonctions avec d'autres fonctions. Une fonction imbriquée est disponible uniquement dans sa fonction parent, à moins qu'une référence à la fonction soit transmise à un code externe. Par exemple, le code suivant déclare deux fonctions imbriquées à l'intérieur de la fonction getNameAndVersion() :

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

Lorsque des fonctions imbriquées sont transmises à un code externe, elles le sont en tant que fonctions closures, ce qui signifie que la fonction conserve les définitions se trouvant dans le domaine au moment de la définition de la fonction. Pour plus d'informations, voir Fonctions closures.