एक सूचकांक हस्ताक्षर पैरामीटर प्रकार एक संघ प्रकार नहीं हो सकता है। इसके बजाय मैप की गई ऑब्जेक्ट प्रकार का उपयोग करने पर विचार करें

Question 1

मैं निम्नलिखित पैटर्न का उपयोग करने की कोशिश कर रहा हूं:

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

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

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

यह मुझे बहुत सीधा लगता है, हालाँकि मुझे निम्नलिखित त्रुटि मिलती है:

एक सूचकांक हस्ताक्षर पैरामीटर प्रकार एक संघ प्रकार नहीं हो सकता है। इसके बजाय मैप की गई ऑब्जेक्ट प्रकार का उपयोग करने पर विचार करें।

मैं क्या गलत कर रहा हूं?

Question 2

आप TS "इन ऑपरेटर" का उपयोग कर सकते हैं और यह कर सकते हैं:

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

Question 3

उपयोग करने के लिए सबसे सरल उपाय है Record

type OptionRequirements = Record<Options, OptionRequirement>

आप इसे स्वयं भी लागू कर सकते हैं:

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

यह निर्माण केवल उपलब्ध है type, लेकिन नहीं interface।

आपकी परिभाषा में समस्या कह रही है कि आपके इंटरफ़ेस की कुंजी टाइप की होनी चाहिए Options, जहां Optionsएक एनम है, न कि एक स्ट्रिंग, संख्या, या प्रतीक।

key in Options"उन विशिष्ट कुंजी संघ प्रकार विकल्प में है कि के लिए" का अर्थ है।

typeउपनाम से अधिक लचीला और शक्तिशाली है interface।

अपने प्रकार वर्ग में इस्तेमाल किया जा करने की जरूरत नहीं होती है, तो चयन typeसे अधिक interface।

Question 4

मुझे कुछ इसी तरह की समस्या थी, लेकिन मेरा मामला इंटरफ़ेस में किसी अन्य फ़ील्ड प्रॉपर्टी के साथ था, इसलिए मेरे समाधान के लिए एक विकल्प के रूप में वैकल्पिक फ़ील्ड प्रॉपर्टी के साथ एक उदाहरण के रूप में था :

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
}

Question 5

इंटरफ़ेस का उपयोग करने के बजाय, मैप की गई ऑब्जेक्ट प्रकार का उपयोग करें

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
}

Question 6

मेरे मामले में मुझे वैकल्पिक होने के लिए गुणों की आवश्यकता थी, इसलिए मैंने यह सामान्य प्रकार बनाया।

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

तो इसे इस तरह से उपयोग करें:

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

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

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

उदाहरण

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

Question 7

मेरा मुद्दा भी ऐसा ही था। मैं केवल विशिष्ट कुंजी का उपयोग करने की कोशिश कर रहा था जब कोणीय रूप सत्यापनकर्ता बना रहा था।

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

export type FormError = keyof typeof FormErrorEnum;

और उपयोग:

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

यह 1 - X नंबर कुंजियों का उपयोग करने की अनुमति देगा।