TypeScript：類中動態聲明的方法

Question

我有一些代碼，如：

const methodsList = [
  'foo',
  'bar',
  // ... 20 other items ...
]

export class Relayer {
  constructor() {
    for (const methodName of methodsList) {
      this[methodName] = (...args) => {
        // console.log('relaying call to', methodName, args)
        // this is same for all methods
      }
    }
  }
}

const relayer = new Relayer()

relayer.foo('asd') // TS error
relayer.bar('jkl', 123) // TS error

現在，當我使用類實例時，TypeScript 會在我調用relayer.foo()或relayer.bar()時抱怨。 為了使代碼編譯，我必須將它轉換as any或類似的。

我有一個聲明foo 、 bar和其他方法的接口：

interface MyInterface {
  foo: (a: string) => Promise<string>
  bar: (b: string, c: number) => Promise<string>
  // ... 20 other methods
}

如何讓 TypeScript 學習動態聲明的foo和bar類方法？ declare語法在這里有用嗎？

Answer 1

第一步是創建一個類型或接口，當以methodsList的值索引時，結果將是一個函數：

// The cast to const changes the type from `string[]` to
// `['foo', 'bar']` (An array of literal string types)
const methodsList = [
    'foo',
    'bar'
] as const

type HasMethods = { [k in typeof methodsList[number]]: (...args: any[]) => any }

// Or
type MethodNames = typeof methodsList[number]  // "foo" | "bar"
                   // k is either "foo" or "bar", and obj[k] is any function
type HasMethods = { [k in MethodNames]: (...args: any[]) => any }

然后，在構造函數中，為了能夠分配methodsList的鍵，您可以添加一個類型斷言，即this is HasMethods ：

// General purpose assert function
// If before this, value had type `U`,
// afterwards the type will be `U & T`
declare function assertIs<T>(value: unknown): asserts value is T

class Relayer {
    constructor() {
        assertIs<HasMethods>(this)
        for (const methodName of methodsList) {
            // `methodName` has type `"foo" | "bar"`, since
            // it's the value of an array with literal type,
            // so can index `this` in a type-safe way
            this[methodName] = (...args) => {
                // ...
            }
        }
    }
}

現在在構造之后，您必須仍然強制轉換類型：

const relayer = new Relayer() as Relayer & HasMethods

relayer.foo('asd')
relayer.bar('jkl', 123)

您還可以在使用工廠函數構造時擺脫強制轉換：

export class Relayer {
    constructor() {
        // As above
    }

    static construct(): Relayer & HasMethods {
        return new Relayer() as Relayer & HasMethods
    }
}

const relayer = Relayer.construct()

另一種解決方法是創建一個新類並在HasMethods對象中創建一個new結果類型斷言：

class _Relayer {
    constructor() {
        assertIs<HasMethods>(this)
        for (const methodName of methodsList) {
            this[methodName] = (...args) => {
                // ...
            }
        }
    }
}

export const Relayer = _Relayer as _Relayer & { new (): _Relayer & HasMethods }

const relayer = new Relayer();

relayer.foo('asd')
relayer.bar('jkl', 123)

或者，如果您只在methodsList使用new和 then 方法，您可以執行以下操作：

export const Relayer = class Relayer {
    constructor() {
        assertIs<HasMethods>(this)
        for (const methodName of methodsList) {
            this[methodName] = (...args) => {
                // ...
            }
        }
    }
} as { new (): HasMethods };

---

您還可以使用MyInterface接口代替HasMethods ，跳過第一步。 這也為您的調用提供了類型安全性。

Answer 2

使用以下語法：

export class Relayer { 
  constructor() {}
  public foo(){
    // your foo method
    this.executedOnEachFunction();
  }
  public bar(){
    // your bar method
    this.executedOnEachFunction();
  }
  executedOnEachFunction(){
    // what you want to do everytime
  }
}

https://repl.it/repls/LawfulSurprisedMineral

Answer 3

對我來說，這聽起來像是需要一個接口。

interface MyInterface {
 foo(): void; // or whatever signature/return type you need
 bar(): void;
  // ... 20 other items ...
}

export class Relayer implements MyInterface {
  constructor() {}

  foo(): void {
    // whatever you want foo to do
  }

  // ... the rest of your interface implementation
}

看起來您正在做的是實現某種接口。 在您的構造函數中，您正在定義方法實現是什么，而不是在類主體中定義它們。 可能有助於閱讀類類型接口