Voici comment fonctionne généralement la fonction async-wait :

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);
})();

Parlons maintenant d'un scénario différent :

Voici un autre exemple de mon fichier index.js dans mon projet NodeJs dans lequel je n'ai pas inclus mon awaitappel dans une asyncfonction (la version de Node que j'utilise est 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"
}

Dans un package.json, “type”la valeur de “module”indique à NodeJs d'interpréter les fichiers avec .jsextension comme utilisant la syntaxe du module ES, par exemple : importinstruction ou import()expressions.

“type” définit comment le runtime NodeJs doit résoudre les spécificateurs ou charger les modules.

Il existe deux valeurs possibles pour “type”config :

1. module
2. commonjs (par défaut)

Voici l'exemple de code (sans typeconfiguration) :

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

Voici le code à l'intérieur index.mjs(exactement le même code que ci-dessus):

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

Voici quelques points tout droit sortis de la documentation officielle de NodeJs :

1. Les fichiers se terminant par .mjssont toujours chargés en tant que modules ES, quel que soit le parent le plus proche package.json.
2. Les fichiers se terminant par .cjssont toujours chargés en tant que CommonJS, quel que soit le parent le plus proche package.json.

Cela ne fonctionne que lorsque awaitl'appel est effectué au niveau supérieur des modules. Voici une illustration :

Le chargeur de module ECMAScript est asynchrone . Cela signifie que l'attente de niveau supérieur permet au module d'agir comme une fonction asynchrone BIG lorsque NodeJs le charge en tant que module ES. Par conséquent, l'attente de niveau supérieur n'a pas besoin d'un wrapper de fonction asynchrone explicite. Cela signifie également qu'une attente sans asynchrone est un mythe !

Clause de non-responsabilité:

Ceci est purement une fonctionnalité de NodeJs. Il n'y a pas de concept de .mjset .cjsdans le JavaScript vanille.

Note de remerciement ❤️

Merci pour la visite. J'espère que vous trouverez cet article utile. Si vous le faites, s'il vous plaît suivez-moi sur le support. Cela m'encouragera vraiment à publier plus de contenu.

PS: Si vous pensez que quelque chose peut être amélioré ou manque d'explications appropriées, envoyez-moi une note dans la zone de commentaire ou envoyez-moi un e-mail à [email protected] . Après tout, tu peux aussi m'apprendre une chose ou deux.