AsyncFunction
=============

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
Le constructeur **`AsyncFunction`** crée un nouvel objet pour une fonction asynchrone. En JavaScript, chaque fonction asynchrone est en fait un objet `AsyncFunction`.

On notera que `AsyncFunction` *n'est pas* un objet global. On peut l'obtenir grâce au code suivant :


```js
Object.getPrototypeOf(async function () {}).constructor;
```

Syntaxe
-------


```js
new AsyncFunction(arg0, corpsFonction);
new AsyncFunction(arg0, arg1, corpsFonction);
new AsyncFunction(arg0, arg1, ...argN, corpsFonction);
```

### Paramètres

`arg1, arg2, ... argN`

Les noms à utiliser comme noms d'arguments formels. Chacun doit être une chaîne de caractères correspondant à un paramètre JavaScript valide (que ce soit un identifiant, un paramètre du reste, ou une affectation par décomposition).

Les paramètres étant analysés comme les déclarations de fonction, les espaces et commentaires sont acceptés. Par exemple : `"x", "laValeur = 42", "[a, b] /* nombres */"` — ou `"x, laValeur = 42, [a, b] /* nombres */"`. (`"x, laValeur = 42", "[a, b]"` est également correct mais moins lisible.)

`corpsFonction`

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

Description
-----------

Les objets de fonction asynchrone créés avec le constructeur `AsyncFunction` sont analysés lorsque la fonction est créée. C'est moins efficace que de déclarer une fonction asynchrone avec une expression de fonction asynchrone et de l'appeler depuis le code, car ces fonctions sont analysées avec le reste du code.

Tous les arguments passés à la fonction sont traités comme les noms des identifiants des paramètres de la fonction qui sera créée, dans l'ordre dans lequel ils sont passés.

**Note :** Les fonctions asynchrones créées avec le constructeur `AsyncFunction` ne créent pas de fermetures avec leurs contextes de création. Elles sont toujours créées dans la portée globale.

Lorsqu'on les exécute, elles ne pourront accéder qu'à leurs variables locales et aux variables globales, pas à celles qui appartiennent à la portée dans laquelle `AsyncFunction` a été appelé.

On aurait donc un comportement différent si on appelait `eval()` avec le code de l'expression de la fonction asynchrone.

Si on appelle `AsyncFunction` comme une fonction (c'est-à-dire sans `new`), cela aura le même effet que s'il est appelé comme un constructeur.

Exemples
--------

### Créer une fonction asynchrone avec le constructeur `AsyncFunction()`


```js
function resoudreApres2Secondes(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

let AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;

let a = new AsyncFunction(
  "a",
  "b",
  "return await resoudreApres2Secondes(a) + await resoudreApres2Secondes(b);",
);

a(10, 20).then((v) => {
  console.log(v); // affiche 30 dans la console après 4 secondes
});
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-objects |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Instruction de fonction asynchrone
* Expression de fonction asynchrone avec les mots-clés `async function`
* `Function`
* Instruction de fonction
* Expression de fonction
* Fonctions et portées de fonction