Function

Le constructeur Function crée un nouvel objet Function. En JavaScript, chaque fonction est un objet Function.

Appeler ce constructeur permet de créer des fonctions dynamiquement mais cette méthode souffre de défauts équivalents à eval en termes de sécurité et de performance. Toutefois, à la différence d'eval, le constructeur Function permet d'exécuter du code dans la portée globale.

Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner https://github.com/mdn/interactive-examples et à envoyer une pull request !

new Function ([arg1[, arg2[, ...argN]],] corpsFonction)

arg1, arg2, ... argN

Les noms utilisés par la fonction pour les arguments formellement déclarés. Chacun doit être une chaîne de caractères correspondant à un identifiant JavaScript valide (ou une liste de telles chaînes séparées par des virgules). Par exemple : "x", "uneValeur", ou "a,b".

corpsFonction

Une chaîne de caractères qui contient les instructions JavaScript définissant la fonction.

Les objets Function créés avec le constructeur Function sont analysés quand la fonction est créée. Ceci est moins efficace que de déclarer une fonction grâce à une expression de fonction ou à une instruction function car celles crées de cette façon sont analysées avec le reste du code.

Tous les arguments passés à la fonction seront traités avec les noms des identifiants des paramètres de la fonction à créer, dans le même ordre dans lequel ils ont été passés. Si un argument n'est pas passé, la valeur du paramètre dans la fonction sera undefined.

Appeler le constructeur Function comme une fonction (c'est-à-dire sans utiliser l'opérateur new) a le même effet que quand il est appelé comme constructeur.

L'objet global Function ne possède pas de méthodes ou de propriétés propres. Cependant, il est lui-même une fonction et hérite de certaines méthodes et propriétés depuis Function.prototype (en-US) grâce à la chaîne de prototype.

Les instances de Function héritent des méthodes et propriétés de Function.prototype (en-US). Comme pour les autres constructeurs, il est possible de modifier le prototype du constructeur afin d'apporter des modifications à toutes les instances de Function.

Le code suivant permet de créer un objet Function qui utilise deux arguments :

// Cet exemple peut être lancé dans votre console JavaScript

// On crée un fonction qui prend deux arguments
// et qui en renvoie la somme
var ajoute = new Function('a', 'b', 'return a + b');

// On appelle la fonction
ajoute(2, 6);
// > 8

Les arguments "a" et "b" sont les noms des arguments formellement déclarés utilisés dans le corps de la fonction : "return a + b".

Les fonctions créées avec le constructeur Function() ne créent pas de fermetures liées au contexte de leur création. Ainsi, lorsqu'elles sont exécutées, elles ne peuvent accéder qu'aux variables globales et à leurs propres valeurs locales. Elles ne peuvent pas accéder aux variables de la portée dans laquelle le constructeur Function a été invoqué. Le comportement est différent de celui qu'on obtient avec eval avec du code contenant une expression de fonction.

var x = 10;

function créerFonction1() {
  var x = 20;
  return new Function("return x;"); // ici |x| fait référence au |x| global
}

function créerFonction2() {
  var x = 20;
  function f() {
    return x; // ici |x| fait référence au |x| local juste avant
  }
  return f;
}

var f1 = créerFonction1();
console.log(f1());          // 10
var f2 = créerFonction2();
console.log(f2());          // 20

Bien que ce code fonctionne dans un navigateur web, l'appel à f1() provoquera une ReferenceError dans Node.js car x ne sera pas trouvé. En effet, pour Node, la portée de plus haut niveau n'est pas la portée globale et x est ici local à la fonction.

• Les fonctions
• L'instruction function
• L'expression function
• L'instruction function*
• L'expression function*
• AsyncFunction
• GeneratorFunction