TypeScript/JavaScript：如何使用decorator模式包装承诺对象

我正试图用包装一个TypeScript（JavaScript）Promise对象，因为我需要在Promise的

then

和

catch

方法（此处未显示）中添加额外的逻辑

到目前为止，看起来是这样的：

export class Decorator {
    protected _promise: Promise<any>;

    constructor(promise: Promise<any>) {
        this._promise = promise;
    }

    then(onFulfilled: any, onRejected: any): Promise<any> {
        return this._promise.then(r => onFulfilled(r), r => onRejected(r))
    };

    catch(onRejected: any): Promise<any> {
        return this._promise.catch(r => onRejected(r));
    }
}

(async () {
    // Note that doSomethingAsynchronously() returns a Promise<void>
    await new Decorator(doSomethingAsynchronously()); // ERROR!!
})();

导出类装饰器{
受保护的承诺：承诺；
建造商（承诺：承诺）{
这就是承诺；
}
然后（履行：任何，拒绝：任何）：承诺{
然后（r=>oncompleted（r），r=>onRejected（r））
};
捕获（拒绝：任何）：承诺{
返回此项。_promise.catch（r=>onRejected（r））；
}
}
（异步（）{
//请注意，doSomethingAsynchronously（）返回一个承诺
等待新的装饰器（doSomethingAsynchronously（））；//错误！！
})();

但是，正如上面的“ERROR！！”注释所指出的，我得到了以下生成错误：

“wait”操作数的类型必须是有效的承诺，或者不能包含可调用的“then”成员

我尝试过扩展承诺（因此类声明将成为

export class Decorator extends Promise

），但随后我必须在构造函数中调用

super（）

，并向其传递一个executor对象，这将大大改变Decorator类。我希望避免需要一个执行者，只希望将内部承诺传递给构造函数

---

我如何才能成功地等待Decorator类的包装承诺呢？

我真的不确定你想要实现什么，我同意@jfriend00。也许问一下你真正想解决的问题，也许你能得到一个更好的答案

不管怎样，这里有一个方法来做你想做的。。。不确定这是否是最好的方式。。。但它是有效的

class Decorator {
    protected _promise: Promise<any>;


    constructor(promise: Promise<any>) {
        this._promise = promise;
    }

    getPromise(onFulfilled?: any, onRejected?: any): Promise<any> {
      return this._promise.then(r => {
        console.log('Decorator:onFulfilled');
        onFulfilled(r);
      })
      .catch(r => {
        console.log('Decorator:onRejected');
        onRejected(r);
      })
    }
}

(async () => {
    // Note that doSomethingAsynchronously() returns a Promise<void>
    const doSomethingAsynchronouslyWithSuccess = () => {
      return new Promise<void>((resolve, reject) => {
        setTimeout(() => resolve(), 1000);
      });
    }
    const doSomethingAsynchronouslyWithFail = () => {
      return new Promise<void>((resolve, reject) => {
        setTimeout(() => reject(), 1000);
      });
    }
    await new Decorator(doSomethingAsynchronouslyWithSuccess()).getPromise();
    await new Decorator(doSomethingAsynchronouslyWithFail()).getPromise();
})();

类装饰器{
受保护的承诺：承诺；
建造商（承诺：承诺）{
这就是承诺；
}
getPromise（OnCompleted？：任何，onRejected？：任何）：承诺{
把这个还给我。然后（r=>{
log（'Decorator:oncompleted'）；
完成（r）；
})
.catch（r=>{
log（'Decorator:onRejected'）；
onr；
})
}
}
（异步（）=>{
//请注意，doSomethingAsynchronously（）返回一个承诺
常数doSomethingAsynchronouslyWithSuccess=（）=>{
返回新承诺（（解决、拒绝）=>{
setTimeout（（）=>resolve（），1000）；
});
}
const doSomethingAsynchronouslyWithFail=（）=>{
返回新承诺（（解决、拒绝）=>{
setTimeout（（）=>reject（），1000）；
});
}
等待新的装饰器（doSomethingAsynchronouslyWithSuccess（））.getPromise（）；
等待新的装饰器（doSomethingAsynchronouslyWithFail（））.getPromise（）；
})();

您真正想解决的问题是什么？请描述并展示这些代码，然后我们可以更好地提供解决实际问题的方法，而不仅仅是尝试对您选择的可能不是最佳方式的特定路径进行评论。仅供参考，这是一个，您描述它的方式，在这里应该避免。相关：