J'aimerais appeler f2
après que f1
soit terminé. La fonction f1
peut être synchrone ou asynchrone . J'ai besoin d'un exemple qui fonctionne dans les deux cas. J'ai trouvé une solution en utilisant une variable Promise
et une minuterie:
global() {
this.f1().then(res => {
this.f2()
})
}
f1() {
return new Promise<any>((resolve, reject) => {
// Some code...
setTimeout( () => {
resolve(x);
}, 1500);
});
}
f2() {
// Some code...
}
Le problème est que le programme doit toujours attendre 1500ms . Je ne veux pas que f2
commence avant que f1
soit terminé . Y a-t-il un moyen d'attendre le temps nécessaire, pas plus ou moins?
Donc, supprimez la partie setTimeout
. Il appellera resolve
ou reject
et passera ensuite l'exécution au prochain gestionnaire then
ou catch
. Si vous avez un appel asynchrone dans la promesse, vous devez appeler resolve/reject
dans le résultat de cet appel.
Qu'en est-il de ne pas attendre 1500ms
- l'heure donnée est en fait l'heure la plus basse après laquelle la fonction peut être appelée. Peut-être qu'après 2000ms
Ceci est lié au thread principal dans lequel le code JS fonctionne. Si le thread principal n'a pas de travail à faire, les résultats des appels asynchrones vont être exécutés.
function f1() {
return new Promise((resolve, reject) => {
console.log('f1');
resolve();
});
}
function f2() {
console.log('f2');
}
f1().then(res => f2());
Si
f1
est synchrone, il n'y a rien de spécial à faire:
global() {
f1();
f2();
}
Si
f1
est asynchrone et renvoie un observable, utilisezRxjs operator
, comme concatMap :
global() {
f1().concatMap(() => f2());
}
Si
f1
est asynchrone et renvoie un promesse, utilisezasync/await
:
async global() {
await f1();
f2();
}
Si
f1
est asynchrone et retourne un Promise (alternative):
global() {
f1().then(res => f2());
}
Il suffit de supprimer le délai d'attente
function f1() {
return new Promise((resolve, reject) => {
console.log('i am first');
resolve();
});
}
function f2() {
console.log('i am second');
}
f1().then(f2);