Travailler avec des promesses à l'intérieur d'un if/else

J'ai une instruction conditionnelle dont j'ai besoin pour effectuer l'une des deux opérations, puis continuer après la selon la opération a résolu. Donc mon code, actuellement, se présente comme suit:

if (shoud_do_thing_a) { //should_do_thing_a is just a variable that determines which function to call. it is not a promise
  do_thing_a()
} else {
  do_thing_b()
}

//more code

Le problème est que les deux do_thing_a et do_thing_b retour des promesses, et je ne peux pas bouger jusqu'à ce quelle est exécutée en a résolu. La meilleure façon que j'ai trouvé pour résoudre ce est comme ceci:

var more_code = function () { 
  //more code
}

if (shoud_do_thing_a) {
  do_thing_a().then(more_code)
} else {
  do_thing_b().then(more_code)
}

Je n'aime pas cette structure. C'est difficile à suivre, car vous avez besoin de sauter partout pour trouver où more_code est défini à l'imaginer, j'ai ce type de contrôle de flux dans plusieurs endroits), plutôt que de simplement être en mesure de continuer la lecture.

Est-il une meilleure façon de faire face à ce genre de chose en javascript?

Ne shoud_do_thing_a représentent un Promise?
pas de. should_do_thing_a est juste une façon simple de vérifier
Alors quel est le problème avec le code en Question?
le premier bloc de code exécutera //more code avant que la promesse se résout. le deuxième bloc de fonctionner correctement, mais il est difficile de suivre le flux de contrôle lors de la lecture.
Voir mise à jour le post. Si ce n'est pas tout à fait clair ce que tu veux dire par "c'est difficile de suivre le flux de contrôle lors de la lecture". Ne more_code() de retour d'appel un Promise?

OriginalL'auteur ewok | 2017-11-02

javascript promise

14

:
```
var more_code = function () { 
    //more code
}

var do_thing;
if (shoud_do_thing_a) {
  do_thing = do_thing_a()
} else {
  do_thing = do_thing_b()
}

do_thing.then(more_code)
```
OU si vous pouvez utiliser async/await
```
async function someFunc() {
    var more_code = function () { 
        //more code
    }

    if (shoud_do_thing_a) {
        await do_thing_a()
    } else {
        await do_thing_b()
    }

    more_code()
}
```
async/await nécessite async à être utilisé lors de la définition de la fonction
En effet, mais depuis l'OP n'a pas d'inclure une définition de fonction dans son extrait de code, je l'ai laissée. Je vais modifier le post pour l'inclure.
async/await ne fonctionne pas. Je reçois un SyntaxError: Unexpected identifier quand j'essaie de définir async func() { ... }
async/await est disponible uniquement dans les versions plus récentes de javascript. Si ce code est exécuté dans le navigateur, vous devrez utiliser promet seul, ou utiliser un transpiler (babel/tapuscrit), etc). Si vous êtes à l'aide d'un noeud, async/await fonctionner dans n'importe quelle 7+ version je crois.
Merci. on dirait que je suis coincé à l'économie de la promesse.

OriginalL'auteur CRice
4

Si vous êtes coincé avec le format raw des Promesses et ne peut pas utiliser async/await (généralement, Vous ne devriez avoir aucune difficulté, ce qui avec babel/tapuscrit etc), ce qui suit est un peu plus élégante que le stockage de la promesse dans une variable:
```
function something() {
  return Promise.resolve()
    .then(() => {
      if (should_do_thing_a) {
        return do_thing_a();
      }
      else if (should_do_thing_b) {
        return do_thing_b();
      }
    })
    .then(some_more_code);
}
```
Notez que lorsque vous commencez à travailler avec des Promesses, vos fonctions doit toujours retourner une Promesse que d'autres fonctions peuvent travailler avec. Laissant une action asynchrone sans aucun moyen de gérer cela signifie mauvaises choses, surtout quand il s'agit d'une erreur de manipulation.

Dans un sens plus général, cela signifie que lorsque vous utilisez les Promesses de votre code est "réjouie" en cours d'exécution et retourné comme des Promesses.

votre point est vrai, mais votre code semble laid. J'ai nettoyé pour vous. (dommage que vous ne pouvez pas avoir plusieurs lignes dans un commentaire, maintenant, ma mise en forme n'est plus là) function doTheThing () { if (shouldDoA) return doThingA() else return doThingB() } doTheThing().then(moreCode)
Je l'ai posté dans une autre réponse, de sorte que le point un peu mieux.

OriginalL'auteur Madara Uchiha
2

Comment je veux améliorer sur d'autres réponses:
- le garder propre et simple
- pas inutiles variables
- retour promesse asap
- en js nous utilisons camelCase
- le mettre dans une fonction et le nom de la fonction à garder lisible
- laisser then exécuter moreCode il est donc appelé après que la chose est faite.
```
function doTheThing () {
  if (shouldDoA) return doThingA()
  else return doThingB()
}

doTheThing().then(moreCode)
```
OriginalL'auteur ThaJay

Enregistrer la promesse et ajouter le puis, après l'instruction if:

var promise;

if (shoud_do_thing_a) {
  promise = do_thing_a();
} else {
  promise = do_thing_b();
}

promise.then(more_code);

OriginalL'auteur Nayish

var promise = shoud_do_thing_a? do_thing_a: do_thing_b

promise().then(function () {
//more code    
})

OriginalL'auteur Peter

La façon dont je le ferais, ce serait de mettre le si de vérifier, dans une autre fonction qui retourne une promesse. La promesse est résolu avec la résolution d'autres appels de fonction dans le if-else.

Exemple:

function performCheck(condition) {
    var defer = $q.defer();
    if (condition) {
        doThingA().then(function(response) {
            defer.resolve(response);
        });
    } else {
        doThingB().then(function(response) {
            defer.resolve(response)
        });
    }
    return defer.promise;
}
performCheck(condition).then(function(response) {
    //Do more code.
});

À mon avis, je préfère cette méthode car cette fonction peut maintenant être utilisé dans plusieurs endroits où vous avez un contrôle sur l'état, la réduction de la duplication de code, et il est plus facile à suivre.

Vous pouvez réduire ce niveau plus bas, avec

function performCheck(condition) {
    var defer = $q.defer();
    var doThisThing = condition ? doThingA : doThingB;
    doThisThing().then(function (response) {
        defer.resolve(response);
    });
    return defer.promise;
}
performCheck(condition).then(function(response) {
    //Do more code.
});

OriginalL'auteur CrazyJane

De travail Simple exemple:

Le champ d'application est défini dans doit être async.

const createUser = async (data) => {
   if (await isUsernameTaken(username)) { return 'username-taken' }
}

La isUsernameTaken func:

const isUsernameTaken = async (username) => {
    const request = await API.SomeRequest
    return !request.isEmpty
}

OriginalL'auteur Oliver Dixon

0

Vous pouvez utiliser async/await
```
async function fn() {
  let p, result;
  if (shoud_do_thing_a) {
    p = await do_thing_a()
  } else {
    p = await do_thing_b()
  }
  if (p) {
    result = more_code();
  }
  return result
}
```
Hmm? Pourquoi êtes-vous en attente de la condition, et pas les fonctions do_thing_a et do_thing_b?
À partir de l'original de lecture de code à la Question shoud_do_thing_a est la variable qui représente un Promise, sinon il n'y a pas de problème de code en Question

OriginalL'auteur guest271314

-1

more_code = miFunc() => return new Promise((resolve, reject) => ... });

Solution 1

const waitFor = should_do_thing_a ? do_thing_a() : do_thing_b();
waitFor.then(...).catch(...)

Solution 2

let waitFor = Promise.resolve();

if (do_thing_a) {
    waitFor = do_thing_a();
} else {
    waitFor = do_thing_b();
}

waitFor.then(...).catch(...);

OriginalL'auteur Jose Mato

Vous devez vous connecter pour publier un commentaire.