Retour sur les fonctions

Enregistrer une fonction dans... une variable ?!

Rappel

1
2
3
4
5

function toto(arg1, arg2)
{
        // code
        return valeur;
}

• Le mot-clé function indique... qu'on déclare une fonction
• toto est le nom de notre fonction
• arg1 et arg2 sont les arguments de cette fonction, séparés par une virgule, et mis entre des parenthèses qui sont obligatoires (même s'il n'y a aucun argument).
• On place le code de la fonction dans un bloc d'instructions, délimité par des accolades.
• On renvoie éventuellement une valeur (c'est la valeur que "prendra" la fonction quand on l'appellera).

Créer une fonction dans une variable

1
2
3
4

var toto = function(arg1, arg2)
{
        // code
}

• On a déclaré notre variable, à l'aide du mot-clé var (comme nous avons vu dans le chapitre à ce sujet).
• On a donné à notre variable le nom de toto.
• On lui a affecté (on lui a donné pour valeur) une fonction, prenant deux paramètres nommés arg1 et arg2, et exécutant le code entre les accolades.

• créer une fonction locale ou globale
• re-déclarer une fonction (autrement dit, modifier son code), simplement en modifiant la variable
• créer des tableaux de fonctions
• etc.

Exemple : un tableau de fonctions

1
2
3
4
5
6

var operation = new Array();
   operation["add"] = function(x,y){ return x+y; };
   operation["soustr"] = function(x,y){ return x-y; };
   operation["mult"] = function(x,y){ return x*y; };
   operation["div"] = function(x,y){ return x/y; };
   operation["moy"] = function(x,y){ return (x+y)/2; };

1
2
3
4
5
6

var a = parseFloat( prompt("Premier nombre ?") );
var b = parseFloat( prompt("Deuxieme nombre ?") );
var fct = prompt("Fonction a appliquer ?");

var resultat = operation[fct](a,b);
alert("Resultat : " + resultat);

Rappel : portée des variables

• On déclare une variable locale à l'aide de var, dans le bloc d'instructions (qui est généralement "matérialisé" par des accolades) dans lequel elle doit être accessible.
• Il y a deux façons de créer une variable globale : soit en la déclarant en dehors de tout bloc d'instructions (tout au début du code JS), soit on l'utilise sans la déclarer, comme si elle l'avait déjà été (on parle alors de déclaration implicite).

1
2
3
4
5
6
7
8

var a;  // on declare une variable globale
function test(argument)
{
        var resultat = 5*argument + 2;
        a = argument;   // modification de la variable globale
        b = resultat;   // declaration implicite d'une variable globale
        return resultat;
}

• Lorsque la fonction n'a pas été appelée, il y a une seule variable globale : a.
• Quand on appelle la fonction, celle-ci modifie cette variable globale, et on en déclare (implicitement) une autre : b.
• Une fois la fonction exécutée, on peut toujours accéder aux variables a et b, car elles sont globales.
• Cependant, on ne peut accéder à la variable resultat uniquement à l'intérieur de la fonction, car c'est une variable locale.

Comment ça se passe lorsqu'on appelle une fonction ?

1
2
3
4

function f(x,y)
{
        // code de la fonction
}

1

f(5);

• deux variables locales, x et y, vont être créées (ce sont les arguments)
• la variable x va être initialisée avec la valeur 5 (c'est la valeur qu'on a donnée lors de l'appel pour le premier argument)
• mais y ne sera pas initialisée, car on n'a pas précisé le second argument

1
2
3

var x, y;
x = 5;
// code de la fonction

Une variable non initialisée !

Quels sont les symptômes ?

1
2

var y;
alert(y);

En effet, undefined est un mot-clé signifiant que la variable est déclarée, mais qu'on ne lui a jamais donné de valeur .
Si la variable n'avait pas été déclarée, on n'aurait pas eu de message du tout : le script aurait été interrompu (l'ordinateur ne peut pas deviner qu'il s'agit d'une variable, puisqu'on ne l'a pas déclarée).

Comment ça se soigne ?

1

if(y == undefined)

1
2
3
4

function isDefined(variable)
{
   return (variable != undefined);
}

1
2
3
4
5
6
7

function isDefined(variable)
{
   if(variable == undefined)
      return false;
   else
      return true;
}

Exemple

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

function dist(a,b)
{
   // on initialise b a 0 si besoin
   if(b == undefined)
      b = 0;
   // on continue ensuite normalement
   if(a > b)
      return a-b;
   else
      return b-a;
}

1
2
3

addition(12, 5);   // nous donnerait 17
addition(21, 4, 15, 11, 6);   // nous donnerait 57
// etc. avec autant de nombres qu'on veut

Où sont stockés tous ces arguments ?

Un tableau contenant tous les arguments

1
2
3
4

function addition()
{
   // corps de la fonction
};

1

addition.arguments = new Array(21, 4, 15, 11, 6);

Le tour est joué !

1

var nb = addition.arguments;

1
2
3
4
5
6
7
8

function addition()
{
   var nb = addition.arguments;
   var somme = 0;
   for(var i=0; i<nb.length; i++)
      somme += nb[i];
   return somme;
};

1
2

alert( addition(12, 5) );
alert( addition(21, 4, 15, 11, 6) );

Un autre exemple

1

function maxi(m) { };

1
2
3
4
5
6
7
8

function maxi(m)
{
   var nb = maxi.arguments;   // on a donc m = nb[0]
   for(var i=1; i<nb.length; i++)
      if(nb[i] > m)   // si l'argument est plus grand que le maximum...
         m = nb[i];   // ... alors c'est le maximum
   return m;
}

1
2
3
4
5

var n = maxi(7, 3);
alert(n);

var p = maxi(2, 8, 4, 1, 9, 4);
alert(p);