重构同步和异步方法实现

Question

假设我们有一个抽象类，该类具有一种抽象方法，可以在同步和异步变体中使用。

abstract class Base
{
    abstract do(): number | Promise<number>;
}

现在，我创建了两个班级的孩子以进行同步和异步用法：

class SyncBase extends Base
{
    do(): number
    {
        console.log('Start');

        /* Sync-class specific code */
        let result = 5;

        console.log('End');

        return result;
    }
}

class AsyncBase extends Base
{
    async do()
    {
        console.log('Start');

        /* Async-class specific code */
        let result = await /* ... */;

        console.log('End');

        return result;
    }
}

如您所见，我在特定于类的代码之前和之后重复代码。

有没有办法重构此代码，所以我只编写一次之前的代码，而不是重复自己？

Answer 1

摘要应该是do函数结果的逻辑。和do函数将处理您的重复逻辑：

abstract class Base {
    do(): number | Promise<number> {
        console.log('Start');

        const result = this.getResult(); // call abstract function

        console.log('End');

        return result;
    };

    abstract getResult(): number | Promise<number>;
}

// Then
class SyncBase extends Base {
    getResult(): number {
        const result = 5;
        // ...
        return result;
    }
}


class AsyncBase extends Base {
    async getResult()
    {
        const result = await Promise.resolve(5);
        // ...
        return result;
    }
}

我的建议：不要混合同步和异步返回类型（numberm | promise＆lt; number＆gt;），只需返回Promise＆lt ; number＆gt;和getResult和do将始终是async始终。