web-dev-qa-db-fra.com

La promesse est synchrone ou asynchrone dans le noeud js

J'ai beaucoup de confusion en promesse. C'est synchrone ou asynchrone?

return new Promise (function(resolved,reject){
    //sync or async? 
});
javascriptnode.jsasynchronouspromisesynchronous
11
udayakumar

La fonction que vous passez into le constructeur Promise s'exécute de manière synchrone, mais tout ce qui dépend de sa résolution sera appelé de manière asynchrone. Même si la promesse se résout immédiatement, tous les gestionnaires s'exécuteront de manière asynchrone (comme lorsque vous setTimeout(fn, 0)) - le thread principal s'exécute jusqu'à la fin en premier.

Cela est vrai quel que soit votre environnement Javascript - que vous soyez dans Node ou un navigateur.

console.log('start');
const myProm = new Promise(function(resolve, reject) {
  console.log('running');
  resolve();
});
myProm.then(() => console.log('resolved'));
console.log('end of main block');
17
CertainPerformance

Les promesses ne sont pas exactement synchrones ou asynchrones en elles-mêmes. Lorsque vous créez une promesse, le rappel que vous lui passez est immédiatement exécuté et aucun autre code ne peut s'exécuter jusqu'à ce que cette fonction cède. Prenons l'exemple suivant:

new Promise(function(resolve, reject) {
  console.log('foo');
})
console.log('bar');

Le code en dehors de la promesse doit attendre que le code à l'intérieur de la promesse (qui est synchrone) se termine avant de pouvoir commencer l'exécution.

Cela dit, les promesses sont un moyen courant de gérer le code asynchrone. Le cas d'utilisation le plus courant pour une promesse est de représenter une valeur générée ou récupérée de manière asynchrone. La logique qui dépend de cette valeur peut attendre de manière asynchrone jusqu'à ce que la valeur soit disponible en enregistrant un rappel avec .then() ou les méthodes Promise associées.

4
Ryan Jenkins

Les promesses sont comme des classes normales en Javascript. Supposons que vous créez votre propre implémentation Promise, votre classe promise ressemblerait à peu près à ceci. Remarquez dans votre constructeur que vous attendez une méthode à passer que vous appelez immédiatement en passant resolve and reject En tant que paramètres.

class Promise {
    constructor(method) {
        method(resolve, reject)
    }

    resolve() { ... }

    reject() { ... }

    then() { ... }
}

Ainsi, lorsque vous effectuez new Promise(), vous créez simplement un nouvel objet. Votre Promise constructor S'exécutera et il appellera immédiatement la méthode. C'est pourquoi le code contenu dans votre promesse est exécuté de manière synchrone.

return new Promise (function(resolved,reject){
    //sync or async? 
});

Si à l'intérieur de votre fonction, vous appelez une autre fonction de nature asynchrone, alors cette autre fonction sera exécutée de manière asynchrone, sinon, tout le reste sera exécuté de manière synchrone.

Si vous aviez des chaînes en promesse à l'aide de then, elle n'est appelée qu'après que votre première promesse a appelé resolve().

return new Promise (function(resolve,reject){
  const a = 5*5; // sync operation.
  db.save(a, function callback() { // async operation.
    resolve() // tells promise to execute `then` block.
  });
});
1
Rash

Lorsque vous créez une promesse et lui renvoyez un appel, ce rappel va être exécuté immédiatement (synchronisation)

const promise= new Promise(function(resolve, reject) {
      //doing some logic it gonna be executed synchronously
       console.log("result");
    })
    console.log("global log")

Mais lorsque vous le résolvez par la méthode .then (), il agira de manière asynchrone, par exemple:

const promise = new Promise(function(resolve, reject) {
  //doing some logic it gonna be executed synchronously

  resolve("fullfiled")
})
promise.then(v => {
  console.log(v)
})
console.log("global log")
0
Oday