如何创建新的承诺？

Question

Well I understand that one would have to return a promise, and not the result of a promise to pass promises around.

However I seem to be unable to implement this, say I have a member method like:

CreateNextBatch() {
  this.orders.clear();
  let maxNum = this.maxNum;
  let counter = this.orderCounter;
  let CreateThem = (counter, r) => {
    if (r >= 0) {
      //Order.find() finds an entry in a database
      Order
        .find({orderNr: counter.fullNumber()})
        .then(function(orders) {
          console.log("created order " + counter.fullNumber().toString());
          let num = r;
          if (orders.length === 0) {
            this.OpenOrder(counter.fullNumber()); 
            //adds order to this.orders
            num -= 1;
          }
          counter.nextNumber();
          return CreateThem(counter, num);
        }.bind(this))
        .catch (function (err){
          console.log(err);
          return false;
        });
    } else {
      return true;
    }
  };
  return () => {CreateThem(counter, maxNum);};
}

Basically it creates orders in a recursive fashion, terminating after finding this.MaxRequests empty spots and then puts them together in a list under this.orders

Now I called this function by:

initialLoader.CreateNextBatch().then(function (success) {
  console.log(success);
  console.log("loaded");
  initialLoader.initializeBatch();
});

However this fails:

 TypeError: initialLoader.CreateNextBatch(...).then is not a function
    at LoadExternDatabase...

Why isn't this working? What am I not understanding yet?

---

Edit: I've also tried to replace the return by a new promise:

  return new Promise((resolve, reject) => {
    CreateThem(counter, maxRequests);
    resolve();
  });

However this executes the resolve immediatelly, instead of waiting for CreateThem to complete. Nor directly the function by return CreateThem.bind(this, counter, maxRequests);

Answer 1

return new Promise((resolve, reject) => {
   globalVarKeep = resolve;
   globalVarBreak = reject;
  });

Before that you would have had some code waiting for a promise or an event that says: -

    CreateThem(counter, maxRequests);
    globalVarKeep();

or

    CreateThem(counter, maxRequests).then(globalVarKeep);

If that's appropriate.

Answer 2

The function initialLoader.CreateNextBatch() returns a function, not a promise, you should do: initialLoader.CreateNextBatch()()

The function CreateThem can return true if this.maxNum >= 0 and a promise of true or false depending on the recursion. But doesn't allways guaranteed return a promise. And () => {CreateThem(counter, maxNum);}; doesn't return anything either. You could try the following:

CreateNextBatch() {
  this.orders.clear();
  let maxNum = this.maxNum;
  let counter = this.orderCounter;
  let CreateThem = (counter, r) => {
    if (r >= 0) {
      //Order.find() finds an entry in a database
      //you can return a promise here
      return Order
        .find({orderNr: counter.fullNumber()})
        .then(function(orders) {
          console.log("created order " + counter.fullNumber().toString());
          let num = r;
          if (orders.length === 0) {
            this.OpenOrder(counter.fullNumber()); 
            //adds order to this.orders
            num -= 1;
          }
          counter.nextNumber();
          return CreateThem(counter, num);
        }.bind(this))
        .catch (function (err){
          console.log(err);
          return false;
        });
    } else {
      return Promise.resolve(true);
    }
  };
  //you are not returning CreateThem here
  return () => {return CreateThem(counter, maxNum);};
}

Answer 3

You should resolve a promise after the asynchronous operation done.

For example:

function test() {
    return new Promise((resolve, reject) => {
        setTimeout(() => { 
              // Resolved here! 
              // Because asynchronous function `setTimeout` ends here
             resolve();  
         }, 1000);
    })
}

In your code, if r >= 0 , it will find an entry in database again until r less than 0 , so it ends at else block:

 if (r >= 0) {
    // ...
 } else { 
   // ends here
  }

Maybe you could change your code to:

CreateNextBatch() {
   return new Promise((resolve, reject) => {
      this.orders.clear();
      let maxNum = this.maxNum;
      let counter = this.orderCounter;
      let CreateThem = (counter, r) => {
        if (r >= 0) {
          //Order.find() finds an entry in a database
          Order
            .find({orderNr: counter.fullNumber()})
            .then(function(orders) {
              console.log("created order " + counter.fullNumber().toString());
              let num = r;
              if (orders.length === 0) {
                this.OpenOrder(counter.fullNumber()); 
                //adds order to this.orders
                num -= 1;
              }
              counter.nextNumber();
              return CreateThem(counter, num);
            }.bind(this))
            .catch (function (err){
              console.log(err);
              reject(err);
            });
        } else {
          resolve(true);
        }
      };
});

//   return () => {CreateThem(counter, maxNum);};
}