Ritorno da una promessa allora ()

Ho un codice javascript come questo:

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

var test = justTesting();

Ho sempre un valore indefinito per il test var. Penso che sia perché le promesse non sono ancora state risolte..c'è un modo per restituire un valore da una promessa?

Quando restituisci qualcosa da una then()richiamata, è un po 'magico. Se restituisci un valore, il successivo then()viene chiamato con quel valore. Tuttavia, se restituisci qualcosa di simile a una promessa, il prossimo then()attende su di esso e viene chiamato solo quando quella promessa si risolve (ha successo / fallisce).

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

Per usare una promessa, devi chiamare una funzione che crea una promessa o devi crearne una tu stesso. Non descrivi realmente quale problema stai cercando di risolvere, ma ecco come creeresti tu stesso una promessa:

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

Oppure, se hai già una funzione che restituisce una promessa, puoi utilizzare quella funzione e restituire la sua promessa:

// 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);
}

Quello che ho fatto qui è che ho restituito una promessa dalla funzione justTesting. È quindi possibile ottenere il risultato quando la funzione viene risolta.

// 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);
  });

Spero che questo ti aiuti!

// old answer

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

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

Preferisco usare il comando "await" e le funzioni asincrone per eliminare le confusioni di promesse,

In questo caso, scriverei prima una funzione asincrona, questa verrà utilizzata al posto della funzione anonima chiamata sotto "promise.then" parte di questa domanda:

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;

}

e quindi chiamerei questa funzione dalla funzione principale:

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

   return lv_result + 1;
}

Notando che ho restituito sia la funzione principale che la funzione secondaria alle funzioni asincrone qui.