Revenez d'une promesse alors ()

J'ai un code javascript comme celui-ci:

function justTesting() {
  promise.then(function(output) {
    return output + 1;
  });
}

var test = justTesting();

J'ai toujours une valeur indéfinie pour le test var. Je pense que c'est parce que les promesses ne sont pas encore résolues .. existe-t-il un moyen de renvoyer une valeur à partir d'une promesse?

Lorsque vous renvoyez quelque chose à partir d'un then()rappel, c'est un peu magique. Si vous renvoyez une valeur, la suivante then()est appelée avec cette valeur. Cependant, si vous retournez quelque chose de semblable à une promesse, le suivant then()attend, et n'est appelé que lorsque cette promesse se règle (réussit / échoue).

Source: https://developers.google.com/web/fundamentals/getting-started/primers/promises#queuing-asynchronous-actions

Pour utiliser une promesse, vous devez soit appeler une fonction qui crée une promesse, soit en créer une vous-même. Vous ne décrivez pas vraiment le problème que vous essayez vraiment de résoudre, mais voici comment créer vous-même une promesse:

function justTesting(input) {
    return new Promise(function(resolve, reject) {
        // some async operation here
        setTimeout(function() {
            // resolve the promise with some value
            resolve(input + 10);
        }, 500);
    });
}

justTesting(29).then(function(val) {
   // you access the value from the promise here
   log(val);
});

// display output in snippet
function log(x) {
    document.write(x);
}

Ou, si vous avez déjà une fonction qui renvoie une promesse, vous pouvez utiliser cette fonction et renvoyer sa promesse:

// function that returns a promise
function delay(t) {
  return new Promise(function(resolve) {
    setTimeout(function() {
      resolve();
    }, t);
  });
}

function justTesting(input) {
  return delay(100).then(function() {
    return input + 10;
  });
}

justTesting(29).then(function(val) {
  // you access the value from the promise here
  log(val);
});

// display output in snippet
function log(x) {
  document.write(x);
}

Ce que j'ai fait ici, c'est que j'ai renvoyé une promesse de la fonction justTesting. Vous pouvez ensuite obtenir le résultat lorsque la fonction est résolue.

// new answer

function justTesting() {
  return new Promise((resolve, reject) => {
    if (true) {
      return resolve("testing");
    } else {
      return reject("promise failed");
   }
 });
}

justTesting()
  .then(res => {
     let test = res;
     // do something with the output :)
  })
  .catch(err => {
    console.log(err);
  });

J'espère que cela t'aides!

// old answer

function justTesting() {
  return promise.then(function(output) {
    return output + 1;
  });
}

justTesting().then((res) => {
     var test = res;
    // do something with the output :)
    }

Je préfère utiliser la commande "await" et les fonctions asynchrones pour me débarrasser des confusions de promesses,

Dans ce cas, j'écrirais d'abord une fonction asynchrone, celle-ci sera utilisée à la place de la fonction anonyme appelée sous "promise.then" partie de cette question:

async function SubFunction(output){

   // Call to database , returns a promise, like an Ajax call etc :

   const response = await axios.get( GetApiHost() + '/api/some_endpoint')

   // Return :
   return response;

}

puis j'appellerais cette fonction à partir de la fonction principale:

async function justTesting() {
   const lv_result = await SubFunction(output);

   return lv_result + 1;
}

Notant que j'ai renvoyé la fonction principale et la fonction secondaire aux fonctions asynchrones ici.