Kehre dann von einem Versprechen zurück ()

Ich habe einen Javascript-Code wie diesen:

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

var test = justTesting();

Ich habe immer einen undefinierten Wert für den Var-Test. Ich denke, das liegt daran, dass die Versprechen noch nicht gelöst sind. Gibt es eine Möglichkeit, einen Wert aus einem Versprechen zurückzugeben?

Wenn Sie etwas von einem then()Rückruf zurückgeben, ist es ein bisschen magisch. Wenn Sie einen Wert zurückgeben, wird der nächste then()mit diesem Wert aufgerufen. Wenn Sie jedoch etwas Versprechendes zurückgeben, then()wartet das nächste darauf und wird nur aufgerufen, wenn dieses Versprechen erfüllt ist (erfolgreich / fehlgeschlagen).

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

Um ein Versprechen zu verwenden, müssen Sie entweder eine Funktion aufrufen, die ein Versprechen erstellt, oder Sie müssen selbst eine erstellen. Sie beschreiben nicht wirklich, welches Problem Sie wirklich lösen möchten, aber so würden Sie selbst ein Versprechen erstellen:

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

Wenn Sie bereits eine Funktion haben, die ein Versprechen zurückgibt, können Sie diese Funktion verwenden und ihr Versprechen zurückgeben:

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

Was ich hier getan habe, ist, dass ich ein Versprechen von der justTesting-Funktion zurückgegeben habe. Sie können das Ergebnis dann erhalten, wenn die Funktion aufgelöst ist.

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

Hoffe das hilft!

// old answer

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

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

Ich bevorzuge die Verwendung von "Warten" -Befehls- und Async-Funktionen, um Verwirrungen von Versprechungen zu beseitigen.

In diesem Fall würde ich zuerst eine asynchrone Funktion schreiben, diese wird anstelle der anonymen Funktion verwendet, die unter "Versprechen.then" Teil dieser Frage aufgerufen wird:

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;

}

und dann würde ich diese Funktion von der Hauptfunktion aus aufrufen:

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

   return lv_result + 1;
}

Ich habe festgestellt, dass ich hier sowohl die Hauptfunktion als auch die Unterfunktion auf asynchrone Funktionen zurückgesetzt habe.