Versprechen innerhalb des Versprechens: Was ist der richtige Weg, um eine Variable aus dem untergeordneten Versprechen zurückzugeben? (JS)

Ich habe eine Funktion wie diese:

function top() {

  //promise1
  ParentPromise({
    ...some code here...
  }).then(function() {


    //promise2
        ChildPromise({
          ..some code here...
        }).then(function(response) {
         var result = response.result.items;

        });

});

};

und ich muss den Ergebniswert auf diese Weise zurückgeben:

var myresult = start();

Wie kann ich das tun? Danke

Die Definition von Versprechen ist, dass man sie nicht buchstäblich zuordnen kann result zu myresult. Jedochdu kannst das schaffen myresult ein Versprechen, das direkt auflöst result Für den Anrufer wurden jedoch viele Versprechungen verwendet, um dies zu erreichen. Die Grundidee ist, dass Sie in jeder Funktion in Ihrem obigen Block sein sollten returndas nächste Versprechen in der Kette. z.B:

function top() {

  //promise1
  return ParentPromise({
    ...some code here...
  }).then(function() {


    //promise2
        return ChildPromise({
          ..some code here...
        }).then(function(response) {
         var result = response.result.items;
         return result;

        });

});

};

Am Ende ruft der Code top() wird nicht wissen oder sich darum kümmern, dass 1, 2 oder 12 verkettete Versprechen verwendet wurden, um zu bekommen result. Es wird auch in der Lage sein, einen Fehlerrückruf zu registrieren, falls eines dieser Versprechen fehlschlägt.

Der sauberste Weg ist meiner Meinung nach, das Versprechen zurückzugeben und sie “unten” anstatt links zu verketten, um eine weihnachtsbaumartige Rückrufhölle zu vermeiden.

function top() {
  //promise1
  return ParentPromise({
    ...some code here...
  }).then(function(parent) {
    //promise2
    return ChildPromise(parent.id)
  }).then(function(response) {
    // do something with `result`

    return response.result.items;
  });
}

top().then(function(items){
  // all done 
});

Bearbeiten:
Oder in ES6 / Lambda-Notation;

function top() {
  return ParentPromise().then(parent => {
    return ChildPromise(parent.id)
  }).then(response => {
    return response.result.items
  })
}

top().then(items => {
  // all done 
})

Bearbeiten: Oder mit Async/Await;

async function top() {
  const parent = await ParentPromise()
  const child = await ChildPromise(parent.id)

  return child.result.items
}

top().then(items => {
  // all done 
})

Die Herausforderung besteht darin, dass Sie versuchen, asynchronen Code synchron zu verwenden. Sie müssen Ihre Denkweise ändern, wenn Sie mit asynchronem Code arbeiten.

Eine Möglichkeit, dies zu lösen, besteht darin, top() ParentPromise zurückgeben zu lassen und dann die Variable myresult mithilfe von .then() der Rückgabe dieses Promise festzulegen.

function top() {
  ...
  return ParentPromie;
}
var myresult=""; // default value until you have resolved your promise
top().then(result => myresult = result);

Damit dies funktioniert, müssen Sie jedoch Code hinzufügen, um Ihr Versprechen aufzulösen:

var ParentPromise = new Promise(function(resolve) { 
  ... some code...
  var ChildPromise = new Promise(function(){
    ...some code...
  }).then(function(response){
    resolve(response.result.items);
  });
});

Führen Sie den folgenden Code aus und erweitern Sie ihn, um ihn an Ihre spezifischen Umstände anzupassen. Beachten Sie, wie es das Zurückgeben von Promises veranschaulicht und an verschiedenen Punkten auf dem Weg Logik hinzufügt, vor, während und nach der Behandlung verschiedener ausstehender Logik.

function ParentPromise(){
  // add complexity here, always returning a promise(s)
  // ie Promise.all, new Promise, Promise.reject or whatever...
  // here for simplicity, just return one to resolve with a clear value
  // to see it at the other end
  return Promise.resolve({items:1234});
}
function start() {
  // any method that returns the first promise, kicking off the complexity
  return ParentPromise(/*
    infinitely complex promise-conflation (individual or Promise.all, etc)
    only requirement is that each ***return a promise***
    where each is resolved or rejected
  */)
  .then((result) => {
    // do something with `result`
    console.log(result.items);
    // note returning what we want to come out **next**
    return result;
  });

};

var myresult;

start()
.then((result)=>{ myresult = result; })
.finally(()=>{ console.log('myresult:',myresult); });

Je nachdem, was Sie wollen

Nehmen wir an, Sie haben ein Modell und einen Rahmen, Sie haben so etwas:

function promiseInsidePromise(req, res) {

    axios.get("example.com/api")

        .then(result => {

            // do something
            result = result + 1;

        })
        .then(result => {
            
            // call the other promise and return it into the chain
            return model.createOrder(result);

        })
        .catch(error => {

            handleError(error, req, res);

        });

}

Sie rufen das andere Versprechen auf, geben aber seinen Wert in die Hauptkette zurück

 return model.createOrder();