मेरे पास कुछ इंटरफेस हैं जो आधार से विस्तारित होते हैं:

enum eItemType { /* … */ }

interface Item {
    someCommonKeyValPairCollection: eItemType;
    type: eItemType;
    weight: number;
    // …
}

interface ItemTypeA extends Item {
    someKeyValPairCollection: eItemType;
}

interface ItemTypeB extends Item {
    someOtherKeyValPairCollection: eItemType;
}

type tItem = Item | ItemTypeA | ItemTypeB

और फिर मेरे पास एक तरीका है जो एक आइटम प्राप्त करता है, लेकिन यह एक (गैर-कीवर्ड) जेनेरिक Item या ItemTypeA या ItemTypeB हो सकता है, इसलिए मैंने संघ प्रकार बनाया tItem. विधि कुछ सामान्य चीजें करती है, और फिर item.type पर आधारित कुछ विशिष्ट चीजें (या तो someKeyValPairCollection या someOtherKeyValPairCollection के माध्यम से लूपिंग। टाइपस्क्रिप्ट बाहर निकलता है, आधा दर्जन असाइनमेंट त्रुटियां फेंकता है, पूर्व Property 'someKeyValPairCollection' is missing in type Item (कोई बकवास नहीं)।

विधि मोटे तौर पर इस तरह दिखती है:

processItem(item: tItem): boolean {
    const isValid: boolean = checkValidity(item);
    if (!isValid) return false;

    _.each(someCommonKeyValPairCollection, () => { /* do some common stuff */ });

    // if (typeof item.someKeyValPairCollection !== 'undefined') // tried first, doesn't like
    if (item.type === eItemType.a) processA(item.someKeyValPairCollection);

    return true;
}

किसी को if (item.type === eItemType.a) // do some special stuff को कैसे संभालना चाहिए?

1
Jakob Jingleheimer 28 अप्रैल 2018, 14:13

1 उत्तर

सबसे बढ़िया उत्तर

आपको एक भेदभावपूर्ण संघ का उपयोग करने की आवश्यकता है। एक संघ जहां एक संपत्ति (type इस मामले में) का एक विशेष प्रकार के लिए एक विशिष्ट मूल्य है। आप यहां विषय के बारे में अधिक पढ़ सकते हैं

enum eItemType {
    a, b, c
}

interface Item {
    someCommonKeyValPairCollection: eItemType;
    type: eItemType;
    weight: number;
    // …
}
interface ItemTypeA extends Item {
    type: eItemType.a
    someKeyValPairCollection: eItemType;
}

interface ItemTypeB extends Item {
    type: eItemType.b
    someOtherKeyValPairCollection: eItemType;
}

interface ItemTypeOther extends Item {
    type: Exclude<eItemType, eItemType.a | eItemType.b>
}


type tItem = ItemTypeA | ItemTypeB | ItemTypeOther
function processItem(item: tItem): boolean {
    if (item.type === eItemType.a) {
        item.someKeyValPairCollection
    }
    else if (item.type === eItemType.b) {
        item.someOtherKeyValPairCollection
    } else {
        item  // will be ItemTypeOther
    }
    return true;
}

संपादित करें

प्रत्येक एनम मान के लिए एक अलग प्रकार को परिभाषित किए बिना या उन्हें अलग-अलग सूचीबद्ध किए बिना शेष एनम मानों को पकड़ने के लिए एक सरल विकल्प जोड़ा गया।

1
Titian Cernicova-Dragomir 29 अप्रैल 2018, 12:41