Les fonctions JavaScript peuvent s'imbriquer

Tout langage de programmation est étendu par la définition de fonctions. En JavaScript elles se déclarents avec le mot-clé function, suivi du nom, entre parenthèses une liste d'arguments et enfin le corps de la fonction entre accolades:

function(a, b)
{
   var x = a + b;
   return x;
}

Noter que les arguments ne sont pas précédés du mot-clé var, inutile, contrairement aux les variables déclarées dans le corps de la fonction.
Les paramètres sont passés par valeurs pour toutes les variables mais pas non lorsqu'il s'agit d'objets.
Ainsi si on change le contenu d'un objet dans le corps d'une fonction, ces modifications demeurent après l'appel de la fonction.

La fonction peut ne rien retourner, ou retourner une valeur unique. Dans le second cas on utilise le mot-clé return.

Une fois définie, une fonction s'appelle selon le format suivant:

function mult(y) { ... }

mult(23);// appel sans valeur retour
z + 3 + mult(44) // dans une expression suppose une valeur de retour
mult(b + 6)  // variable ou expression en paramètre

Des arguments optionnels avec des valeurs par défaut

Les arguments d'une fonction JavaScript sont tous optionnels car l'interpréteur place les paramètres dans un tableau, et les retrouve en interne par le nom de variable qui sert d'index.

Exemple:

fonction maFonct(x, y, z)

La fonction peut être invoquée par:

maFonct(10);   // ou
maFonct(a, 5); // ou
maFonct(1, 2, 3);

En fait x, y, z sont pour l'interpréteur les clés d'un tableau associatif dont les valeurs sont les paramètres passés à l'appel de la fonction.

A l'inverse le programmeur peut ajouter lors de l'appel de la fonction, des paramètres non prévus dans sa déclaration. Par exemple:

maFonct(0, 10, 20, 30, 40, 50, 60);

Les paramètres ajoutés sont pris en compte avec le tableau des arguments, qui est un mot-clé du langage et s'appelle arguments. Le programmeur retrouve les paramètres par leur position dans le tableau, le premier ayant l'indice 0.

Les attributs de la variable prédéfinie argument sont:
length: le nombre d'éléments dans le tableau.
callee: le nom de la fonction dont ce sont les arguments.

Dans l'exemple d'appel de fonction avec paramètres surnuméraires précédent, cette ligne placée dans le corps de la fonction:

alert(arguments[3]);

afficherait 30.

Exemple montrant que l'on peut ajouter des paramètres lors d'un appel de fonction 

function myFun(x, y) 
{
  var result=x;
  result += "-";
  result += y;
  for (var i = 2;  i < arguments.length; i++) 
  {
    result += "-" + arguments[i];
  }
  return result;
}
function test()
{
  var x = myFun("a", "b", "c", "d", "e") ;
  alert(x);
}

Cliquez:

JavaScript ne reconnaît pas les valeurs par défaut. Par exemple function x(a = 33) n'est pas valide dans ce langage alors que c'est reconnu par PHP ou C.

On peut utiliser différentes alternatives comme tester dans le corps de la fonction si la variable est déclarée pour lui assigner autrement une valeur. Par exemple: 

var myFun = function(x) 
{
  if (x === undefined) { x = 33; }
}
myFun();

Exemple de fonction déclarée dans une autre et comment on y accède

Il est possible de définir des fonctions dans la déclaration d'une autre fonction, et les règles de visibilité en cascades s'appliquent:

function outer(a)
{
  function inner(b)
 {
    return b * 2;
 }
 return inner(a)
}

var z = outer(5);
alert(z);

Les variables de la fonction outer sont accessibles à la fonction inner.

function outer(a)
{
  function inner(b)
  {
    return b * 2 + a;
  }
  return inner(a);
}
var z = outer(5);
document.write(z);

Cela permet en fait d'utiliser des fonctions pour créer des objets et leur ajouter des méthodes sous forme de fonctions internes.

Voir aussi

© 2007-2012 Xul.fr