Bir dizin imzası parametre türü bir birleşim türü olamaz. Bunun yerine eşlenmiş bir nesne türü kullanmayı düşünün

Aşağıdaki kalıbı kullanmaya çalışıyorum:

enum Option {
  ONE = 'one',
  TWO = 'two',
  THREE = 'three'
}

interface OptionRequirement {
  someBool: boolean;
  someString: string;
}

interface OptionRequirements {
  [key: Option]: OptionRequirement;
}

Bu bana çok basit görünüyor, ancak şu hatayı alıyorum:

Bir dizin imzası parametre türü bir birleşim türü olamaz. Bunun yerine eşlenmiş bir nesne türü kullanmayı düşünün.

Neyi yanlış yapıyorum?

TS "in" operatörünü kullanabilir ve bunu yapabilirsiniz:

enum Options {
  ONE = 'one',
  TWO = 'two',
  THREE = 'three',
}
interface OptionRequirement {
  someBool: boolean;
  someString: string;
}
type OptionRequirements = {
  [key in Options]: OptionRequirement; // Note that "key in".
}

En basit çözüm kullanmaktır Record

type OptionRequirements = Record<Options, OptionRequirement>

Kendiniz de şu şekilde uygulayabilirsiniz:

type OptionRequirements = {
  [key in Options]: OptionRequirement;
}

Bu yapı yalnızca kullanılabilir type, ancak değil interface.

Tanımınızdaki problem, arayüzünüzün anahtarının bir dizge, sayı veya sembol değil, bir enum Optionsolduğu türde olması gerektiğini söylemektir Options.

key in Options"Sendika tipi Seçenekleri var bu özel tuşlar için" anlamına gelir.

typealias daha esnek ve güçlüdür interface.

Senin tipin sınıfında kullanılmak üzere ihtiyaç yoksa, seçim typeüzerinde interface.

Benzer bir sorun yaşadım ama benim durumum arayüzde başka bir alan özelliğindeydi, bu nedenle çözümüm, anahtarlar için bir numaralandırmalı isteğe bağlı alan özelliğine sahip bir örnek olarak :

export enum ACTION_INSTANCE_KEY {
  cat = 'cat',
  dog = 'dog',
  cow = 'cow',
  book = 'book'
}

type ActionInstances = {
  [key in ACTION_INSTANCE_KEY]?: number; // cat id/dog id/cow id/ etc // <== optional
};

export interface EventAnalyticsAction extends ActionInstances { // <== need to be extended
  marker: EVENT_ANALYTIC_ACTION_TYPE; // <== if you wanna add another field to interface
}

Arayüz kullanmak yerine eşlenmiş bir nesne türü kullanın

enum Option {
  ONE = 'one',
  TWO = 'two',
  THREE = 'three'
}

type OptionKeys = keyof typeof Option;

interface OptionRequirement {
  someBool: boolean;
  someString: string;
}

type OptionRequirements = {                 // note type, not interface
  [key in OptionKeys]: OptionRequirement;   // key in
}

Benim durumumda özelliklerin isteğe bağlı olmasına ihtiyacım vardı, bu yüzden bu genel türü yarattım.

type PartialRecord<K extends string | number | symbol, T> = { [P in K]?: T; };

O halde şu şekilde kullanın:

type MyTypes = 'TYPE_A' | 'TYPE_B' | 'TYPE_C';

interface IContent {
    name: string;
    age: number;
}

interface IExample {
    type: string;
    partials: PartialRecord<MyTypes, IContent>;
}

Misal

const example : IExample = {
    type: 'some-type',
    partials: {
        TYPE_A : {
            name: 'name',
            age: 30
        },
        TYPE_C : {
            name: 'another name',
            age: 50
        }
    }
}

Benzer bir sorun yaşadım. Açısal form doğrulayıcıları oluştururken yalnızca belirli anahtarları kullanmaya çalışıyordum.

export enum FormErrorEnum {
  unknown = 'unknown',
  customError = 'customError',
}

export type FormError = keyof typeof FormErrorEnum;

Ve kullanım:

static customFunction(param: number, param2: string): ValidatorFn {
  return (control: AbstractControl): { [key: FormErrorEnum]?: any } => {
    return { customError: {param, param2} };
  };
}

Bu, 1 - X sayıda anahtarın kullanılmasına izin verecektir.