Mam kod taki jak:

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

Teraz, gdy używam instancji klasy, TypeScript narzeka, gdy wywołuję relayer.foo() lub relayer.bar(). Aby kod się skompilował, muszę go rzucić as any lub podobny.

Mam interfejs, który deklaruje foo, bar i inne metody:

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

Jak sprawić, by TypeScript nauczył się dynamicznie zadeklarowanych metod klas foo i bar? Czy składnia declare może być tutaj przydatna?

0
Elmo 31 marzec 2020, 16:30

3 odpowiedzi

Najlepsza odpowiedź

Pierwszym krokiem jest utworzenie typu lub interfejsu, w którym po indeksowaniu przez wartość w methodsList wynikiem będzie funkcja:

// 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 }

Następnie w konstruktorze, aby móc przypisać klucze methodsList, możesz dodać potwierdzenie typu, które 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) => {
                // ...
            }
        }
    }
}

Teraz po skonstruowaniu musisz jeszcze rzucić typ:

const relayer = new Relayer() as Relayer & HasMethods

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

Możesz także pozbyć się odlewów, jeśli zbudujesz je przy użyciu funkcji fabrycznej:

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

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

const relayer = Relayer.construct()

Innym sposobem obejścia tego jest utworzenie nowej klasy i potwierdzenie typu, że new daje w wyniku obiekt HasMethods:

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)

Lub jeśli używasz tylko new, a następnie metod w methodsList, możesz:

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

Możesz także użyć interfejsu MyInterface zamiast HasMethods, pomijając pierwszy krok. Zapewnia to również bezpieczeństwo typów w połączeniach.

1
Artyer 9 kwiecień 2020, 23:43

Dla mnie brzmi to jak potrzeba interfejsu.

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
}

Wygląda na to, że robisz zaimplementowanie pewnego rodzaju interfejsu. W swoim konstruktorze definiujesz implementacje metod zamiast definiować je w treści klasy. Pomocne może być przeczytanie interfejsów typów klas

0
Andrew Nolan 31 marzec 2020, 14:06

Użyj następującej składni:

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

1
Benjamin Collignon 31 marzec 2020, 14:28