Javascript 如何从函数返回不同的承诺？

我有一个

createOrder

函数，它应该返回一个承诺。我在函数中有数据库调用，我想在所有数据库操作完成后解决

createOrder

函数的承诺

问题是typescript编译器不允许我从数据库函数returned promise内部返回承诺，因为它认为函数声明（returna promise）没有得到满足：

A function whose declared type is neither 'void' nor 'any' must return a value.

createOrder（顺序：数组，总和：数字）：承诺{
this.db.put（newOrder）
。然后（（r）=>{
//其他业务
返回新承诺（（解决）=>{
决议（命令）；
});
})
.catch（函数（err）{
log（'put order:'，err）；
//返回新承诺（（拒绝）=>{
//拒绝（命令）；
// });
});
}

我可以在函数的末尾返回一个承诺，但这当然对编译器之外的任何东西都不好。我应该在这里使用一个简单的回调吗？

试试下面的方法

createOrder(order:Array<Cartitem>, sum:number):Promise<Array<Cartitem>> {
    this.db.put(newOrder)
        .then((r)=>{
           //other operations
           return new Promise<Array<Cartitem>>((resolve) => {
               resolve(order);
           });
        })
        .catch(function (err) {
           console.log('put order:', err);
           // return new Promise<Array<Cartitem>>((reject) => {
           //   reject(order);
           // });
        });
}

createOrder（顺序：数组，总和：数字）：承诺{
返回此.db.put（newOrder）
。然后（（r）=>{
//其他业务
返回新承诺（（解决）=>{
决议（命令）；
});
})
.catch（函数（err）{
log（'put order:'，err）；
//返回新承诺（（拒绝）=>{
//拒绝（命令）；
// });
返回空
});
}

根据您在“其他操作”中所做的操作，您可以使用通过调用

创建的承诺，然后在
这个.db.put上使用
的承诺，如果可以：

createOrder(order:Array<Cartitem>, sum:number):Promise<Array<Cartitem>> {
    return this.db.put(newOrder)
        .then((r)=>{
           //other operations
           return new Promise<Array<Cartitem>>((resolve) => {
               resolve(order);
           });
        })
        .catch(function (err) {
           console.log('put order:', err);
           // return new Promise<Array<Cartitem>>((reject) => {
           //   reject(order);
           // });
           return null
        });

}

实际上，您应该添加
this.db.put的
return
（以及它后面的整个表达式）

目前，您正在调用
this.db.put
，并在then分支中链接回调，但您没有向调用方返回任何内容。随后，调用方可能希望能够
。然后
关闭
createOrder
的结果，但在普通的旧JavaScript中，它将失败，因为结果将是未定义的

您也可以只在
中
解析（顺序）
。然后
，而不是返回数组的承诺等。
您可以将承诺作为函数的返回值返回，并在内部承诺回调中解析它：

createOrder(order:Array<Cartitem>, sum:number):Promise<Array<Cartitem>> {
    return new Promise<Array<Cartitem>>((resolve) => {
        this.db.put(newOrder)
            .then((r)=>{
               //other operations
               resolve(order);
            })
            .catch(function (err) {
               console.log('put order:', err);
               reject(err); // You had `order` here, but presumably it would be `err`
            });
    });
}

createOrder（顺序：数组，总和：数字）：承诺
{
返回新承诺（（解决）=>{
this.db.put（newOrder）
。然后（（r）=>{
//其他业务
决议（命令）；
})
.catch（（错误）=>{
log（'put order:'，err）；
拒绝（错误）；
});
});
}
谢谢大家，这太快了！
createOrder(order:Array<Cartitem>, sum:number):Promise<Array<Cartitem>> {
    return new Promise<Array<Cartitem>>((resolve) => {
        this.db.put(newOrder)
            .then((r)=>{
               //other operations
               resolve(order);
            })
            .catch(function (err) {
               console.log('put order:', err);
               reject(err); // You had `order` here, but presumably it would be `err`
            });
    });
}

createOrder(order:Array<Cartitem>, sum:number):Promise<Array<Cartitem>>  
{
   return new Promise<Array<Cartitem>>((resolve) => {
      this.db.put(newOrder)
        .then((r)=>{
            //other operations
           resolve(order);
        })
        .catch((err) => {
           console.log('put order:', err);
           reject(err);
        });
   });
}