Así es como funciona normalmente la función async-await:

function myDummyBackendCall() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        name: "Shivang",
        id: "asmdhajkdhajdsh8qweuqoweuiqepoi-0q-0eueiuaisjdaKcjaisku",
      });
    });
  });
}

// Used an async wrapper function to make an await call
(async () => {
  let data = await myDummyBackendCall();
  console.log(data);
})();

Hablemos ahora de un escenario diferente:

Aquí hay otro ejemplo de mi archivo index.js dentro de mi proyecto NodeJs en el que no he incluido mi awaitllamada dentro de una asyncfunción (la versión de nodo que estoy usando es 19.3.0):

function myDummyBackendCall() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        name: "Shivang",
        id: "asmdhajkdhajdsh8qweuqoweuiqepoi-0q-0eueiuaisjdaKcjaisku",
      });
    });
  });
}

//Note that there is no async wrapper function

let data = await myDummyBackendCall();
console.log(data);

// Output of node index.js
{
  name: 'Shivang',
  id: 'asmdhajkdhajdsh8qweuqoweuiqepoi-0q-0eueiuaisjdaKcjaisku'
}

{
  "name": "src",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type":"module", // I'm here!
  "scripts": {
    "test": "echo \\"Error: no test specified\\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Dentro de un package.json, el “type”valor de “module”le dice a NodeJs que interprete los archivos con .jsextensión como si usaran la sintaxis del módulo ES, por ejemplo: importdeclaraciones o import()expresiones.

“type” define cómo el tiempo de ejecución de NodeJs debe resolver los especificadores o cargar módulos.

Hay dos valores posibles para “type”config:

1. módulo
2. commonjs (predeterminado)

Aquí está el código de muestra (sin typeconfiguración):

{
  "name": "src",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \\"Error: no test specified\\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Aquí está el código interior index.mjs(exactamente el mismo código que el anterior):

function myDummyBackendCall() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        name: "Shivang",
        id: "asmdhajkdhajdsh8qweuqoweuiqepoi-0q-0eueiuaisjdaKcjaisku",
      });
    });
  });
}
  
console.log(await myDummyBackendCall());

Aquí hay algunos puntos directamente de la documentación oficial de NodeJs :

1. Los archivos que terminan en .mjssiempre se cargan como módulos ES, independientemente del padre más cercano package.json.
2. Los archivos que terminan en .cjssiempre se cargan como CommonJS independientemente del padre más cercano package.json.

Esto solo funciona cuando awaitla llamada se realiza en el nivel superior de los módulos. Aquí hay una ilustración:

El cargador de módulos ECMAScript es asíncrono . Significa que la espera de nivel superior permite que el módulo actúe como una GRAN función asíncrona cuando NodeJs lo carga como Módulo ES. Por lo tanto, la espera de nivel superior no necesita un contenedor de función asíncrono explícito. ¡También significa que una espera sin asíncrono es un mito!

Descargo de responsabilidad:

Esta es puramente una característica de NodeJs. No existe el concepto de .mjsy .cjsen JavaScript vainilla.

Nota de agradecimiento ❤️

Gracias por detenerte. Espero que encuentres útil este artículo. Si es así, sígueme en medium. Eso realmente me animará a publicar más contenido.

PD: Si cree que algo puede mejorarse o carece de una explicación adecuada, envíeme una nota en el cuadro de comentarios o envíeme un correo electrónico a [email protected] . Después de todo, también puedes enseñarme una o dos cosas.