Funciones asíncronas
====================

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

 El **constructor `AsyncFunction`** crea un nuevo objeto async function.
 En JavaScript, cada función asíncrona es un objeto `AsyncFunction`.

Nota: `AsyncFunction` *no* es un objeto global. Este puede ser obtenido como resultado del siguiente código.


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

Sintaxis
--------


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

### Parámetros

`arg1, arg2, ... argN`

Nombres a ser usados por la función como los nombres de los argumentos. Cada uno debe ser una cadena que corresponda a un identificador válido en JavaScript (cualquier identificador, parámetro rest, o parámetro desestructurado, opcionalmente con un valor por defecto), o una lista de tales cadenas separadas por comas.

Así mismo, los parámetros se procesan de la misma manera que las declaraciones de funciones, aceptando espacios y comentarios. Por ejemplo: `"x", "theValue = 42", "[a, b] /* numbers */"` — o `"x, theValue = 42, [a, b] /* numbers */"`. (`"x, theValue = 42", "[a, b]"` es también correcto, pero muy confuso para leer).

`functionBody`

Una cadena que contiene las sentencias de JavaScript que componen la definición de la función.

Descripción
-----------

Los objetos `async function` creados con el constructor `AsyncFunction` son procesados en el momento que la función es creada. Esto es menos eficiente que declarar una función asincrona con un `async function expression` y llamarla con eso en tu código , ya que las funciones son procesadas junto al resto del código.

Todos los argumentos que son pasados a la función son tratados por los nombres de los identificadores de los parámetros en la función creada, en el orden en que son pasados a la función.

**Nota:** Las async functions creadas con el constructor `AsyncFunction` no crean
 *closures* en sus contextos creados, siempre son creados en el contexto global.


 Cuando se ejecutan, solamente podran acceder a sus variables locales y globales, no a las variables de otros contextos en el cual
 el constructor `AsyncFuction` fue llamado.


 Esto es distinto de usar `eval` con código para
 una expresión de función asíncrona.


Invocar el constructor `AsyncFunction` coomo una función (sin usar el operador `new`) tiene el mismo efecto que invocarlo como un constructor.

Ejemplos
--------

### Creando una función asíncrona con el constructor AsyncFunction()


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

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

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

a(10, 20).then((v) => {
  console.log(v); // imprime 30 después de 4 segundos
});
```

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Véase también
-------------

* async function function
* async function expression
* `Function`
* function statement
* function expression
* Functions and function scope