Paramètres de fonction -- Flash CS3

ActionScript 3.0 permet d'exploiter des paramètres de fonction qui peuvent sembler nouveaux pour les programmeurs qui découvrent le langage. Bien que la majorité des programmeurs devrait maîtriser le transfert de paramètres par valeur ou par référence, l'objet arguments et le ... paramètre (rest) peut être nouveau pour un grand nombre d'entre vous.

Sous-rubriques

Transfert d'arguments par valeur ou par référence

Dans de nombreux langages de programmation, il est important de comprendre la différence entre le transfert d'arguments par valeur ou par référence car elle peut affecter la façon dont le code est conçu.

Transférer par valeur signifie que la valeur de l'argument est copiée dans une variable locale pour être utilisée dans la fonction. Transférer par référence signifie que seule une référence à l'argument est transmise, au lieu de la valeur réelle. Aucune copie de l'argument réel n'est effectuée. A la place, une référence à la variable transférée en tant qu'argument est créée et affectée à une variable locale pour être utilisée dans la fonction. En tant que référence à une variable en dehors de la fonction, la variable locale vous permet de modifier la valeur de la variable d'origine.

Dans ActionScript 3.0, tous les arguments sont transférés par référence car toutes les valeurs sont stockées en tant qu'objets. Néanmoins, les objets qui appartiennent aux types de données primitifs (Boolean, Number, int, uint, et String) possèdent des opérateurs spéciaux qui font qu'ils se comportent comme s'ils étaient transférés par valeur. Par exemple, le code suivant crée une fonction appelée passPrimitives() qui définit deux paramètres appelés xParam et yParam de type int. Ces paramètres sont identiques aux variables locales déclarées dans le corps de la fonction passPrimitives(). Lorsque la fonction est appelée avec les arguments xValue et yValue, les paramètres xParam et yParam sont initialisés avec des références aux objets int représentés par xValue et yValue. Les arguments se comportent comme s'ils étaient transférés par valeur car ils sont primitifs. Bien que xParam et yParam contiennent initialement des références aux objets xValue et yValue uniquement, toute modification apportée aux variables dans le corps de fonction génère de nouvelles copies des valeurs dans la mémoire.

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

Dans la fonction passPrimitives(), les valeurs de xParam et yParam sont incrémentées, mais ceci n'affecte pas les valeurs de Value et yValue, comme indiqué dans la dernière instruction trace . Ceci s'applique même si les paramètres portent les mêmes noms que les variables, xValue et yValue, car les xValue et yValue se trouvant dans la fonction pointeraient vers de nouveaux emplacements dans la mémoire qui existent indépendamment des variables du même nom en dehors de la fonction.

Tous les autres objets (c'est-à-dire les objets qui n'appartiennent pas aux types de données primitifs) sont toujours transférés par référence. Ceci vous permet de modifier la valeur de la variable d'origine. Par exemple, le code suivant crée un objet appelé objVar avec deux propriétés, x et y. L'objet est transféré en tant qu'argument à la fonction passByRef(). Etant donné que l'objet n'est pas un type primitif, non seulement il est transféré par référence mais il reste également une référence. Ceci signifie que les changements effectués sur les paramètres dans la fonction affectent les propriétés d'objet en dehors de la fonction.

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

Le paramètre objParam référence le même objet que la variable globale objVar. Comme vous pouvez le constater dans les instructions trace de l'exemple, les modifications apportées au propriétés x et y de l'objet objParam sont visibles dans l'objet objVar.

Valeurs de paramètre par défaut

Dans ActionScript 3.0, il est à présent possible de déclarer des valeurs de paramètre par défaut pour une fonction. Si un appel à une fonction avec des valeurs de paramètre par défaut omet un paramètre avec des valeurs par défaut, la valeur spécifiée dans la définition de fonction pour ce paramètre est utilisée. Tous les paramètres avec des valeurs par défaut doivent être placés à la fin de la liste des paramètres. Les valeurs affectées comme valeurs par défaut doivent être des constantes de compilation. L'existence d'une valeur par défaut pour un paramètre le rend facultatif. Un paramètre sans valeur par défaut est considéré comme un paramètre obligatoire.

Par exemple, le code suivant crée une fonction avec trois paramètres, dont deux possèdent des valeurs par défaut. Lorsque la fonction est appelée avec un seul paramètre, les valeurs par défaut pour les paramètres sont utilisées.

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

L'objet arguments

Lorsque les paramètres sont transférés à une fonction, vous pouvez utiliser l'objet arguments pour accéder aux informations concernant les paramètres transférés à votre fonction. Voici certains aspects importants de l'objet arguments :

ActionScript 3.0 permet aux appels de fonction d'inclure plus de paramètres que ceux définis dans la définition de fonction mais génère une erreur de compilateur en mode strict si le nombre de paramètres est inférieur au nombre de paramètres obligatoires. Vous pouvez utiliser l'aspect de tableau de l'objet arguments pour accéder aux paramètres transférés à la fonction, que ces paramètres soient définis ou non dans la définition de fonction. L'exemple suivant utilise le tableau arguments et la propriété arguments.length pour suivre tous les paramètres transférés à la fonction traceArgArray() :

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

traceArgArray(1, 2, 3);

// résultat :
// 1
// 2
// 3

La propriété arguments.callee est souvent utilisée dans des fonctions anonymes pour créer une récursivité. Vous pouvez l'utiliser pour ajouter de la flexibilité à votre code. Si le nom de la fonction récursive change pendant votre cycle de développement, il est inutile de modifier l'appel récursif dans le corps de votre fonction si vous utilisez arguments.callee au lieu du nom de fonction. La propriété arguments.callee est utilisée dans l'expression de fonction suivante pour activer la récursivité :

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

trace(factorial(5)); // 120

Si vous utilisez le paramètre ... (rest) dans votre déclaration de fonction, l'objet arguments n'est pas disponible. Vous devez accéder aux paramètres à l'aide des noms de paramètre que vous avez déclarés.

N'utilisez pas la chaîne "arguments" comme nom de paramètre car elle masque l'objet arguments. Par exemple, si la fonction traceArgArray() est réécrite de façon à ce qu'un paramètre arguments soit ajouté, les références à arguments dans le corps de la fonction se réfèrent au paramètre plutôt qu'à l'objet arguments. Le code suivant donne le résultat :

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

traceArgArray(1, 2, 3);

// aucun résultat

L'objet arguments dans les versions précédentes d'ActionScript contenait également une propriété appelée caller, qui est une référence à la fonction qui appelait la fonction actuelle. La propriété caller n'existe pas dans ActionScript 3.0, mais si vous avez besoin d'une référence à la fonction d'appel, vous pouvez modifier la fonction d'appel de façon à ce qu'elle transfère un paramètre supplémentaire qui en soit une référence.

Le paramètre ... (rest)

ActionScript 3.0 présente une nouvelle déclaration de paramètre appelée le paramètre ... (rest). Ce paramètre vous permet de spécifier un paramètre de tableau qui accepte n'importe quel nombre d'arguments séparés par des virgules. Veillez à ne pas inclure un mot réservé dans le nom du paramètre. Cette déclaration de paramètre doit être le dernier paramètre spécifié. Ce paramètre rend l'objet arguments non disponible. Bien que le paramètre ... (rest) offre la même fonctionnalité que le tableau arguments et la propriété arguments.length, il ne fournit pas la même fonctionnalité que arguments.callee. Vérifiez que vous n'avez pas besoin d'utiliser arguments.callee avant d'utiliser le paramètre ... (rest).

L'exemple suivant réécrit la fonction traceArgArray() à l'aide du paramètre ... (rest) au lieu de l'objet arguments :

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

traceArgArray(1, 2, 3);

// résultat :
// 1
// 2
// 3

Le paramètre ... (rest) peut également être utilisé avec d'autres paramètres, à partir du moment où il est le dernier paramètre de la liste. L'exemple suivant modifie la fonction traceArgArray() de façon à ce que son premier paramètre, x, soit de type int, et que le second utilise le paramètre ... (rest). Le résultat ignore la première valeur car le premier paramètre ne fait plus partie du tableau créé par le paramètre ... (rest).

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

traceArgArray(1, 2, 3);

// résultat :
// 2
// 3