web-dev-qa-db-fra.com

Angular/TypeScript - Appelle une fonction après qu'une autre soit terminée

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?

angulartypescriptasynchronouspromisesynchronous
6
veben

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

4
Suren Srapyan

Si f1 est synchrone, il n'y a rien de spécial à faire:

global() {
    f1();
    f2();
}

Si f1 est asynchrone et renvoie un observable, utilisez Rxjs operator, comme concatMap :

global() {
    f1().concatMap(() => f2());
}

Si f1 est asynchrone et renvoie un promesse, utilisez async/await:

async global() {
    await f1();
    f2();
}

Si f1 est asynchrone et retourne un Promise (alternative):

global() {
    f1().then(res => f2());
}
2
veben

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);
0
S. Stumm