Typescript: सभी यूनियन सदस्यों पर परिभाषित गुणों के लिए ऑब्जेक्ट प्रकारों के संघ में संपत्ति तक पहुँचना विफल रहता है

डॉक्टर कहते हैं:

समान कोड काम करने के लिए, हमें एक प्रकार के दावे का उपयोग करने की आवश्यकता होगी:

let pet = getSmallPet();

if ((<Fish>pet).swim) {
    (<Fish>pet).swim();
}
else {
    (<Bird>pet).fly();
}

http://www.typescriptlang.org/docs/handbook/advanced-types.html

फिर अपने नमूने में:

if ((<A>AorB).a) {
    // use AorB.a
}

यहाँ मुद्दा यह है कि क्योंकि B a संपत्ति की घोषणा नहीं करता है, यह रन-टाइम पर किसी भी संभावित प्रकार के a संपत्ति हो सकता है (क्योंकि आप एक असाइन कर सकते हैं गुणों के किसी भी सेट के साथ वस्तु B रूप में लंबे समय के रूप में यह b प्रकार की स्ट्रिंग की संपत्ति है)। आप यह स्पष्ट रूप से एक की घोषणा काम कर सकते हैं a: undefined में संपत्ति B (इस प्रकार सुनिश्चित करना है कि B कुछ यादृच्छिक नहीं होगा a संपत्ति):

type A = { a: string; } 
type B = { b: string; a: undefined }
type AorB = A | B;

declare const AorB: AorB;

if (AorB.a) {
    // Ok
}

एकदम सही समझ में आता है। दिमाग़ का दही।

यदि आप B को a: undefined परिभाषित करते हैं, तो आपको एक चर बनाते / पास करते समय इसे undefined पर सेट करना होगा।
उस के आसपास पाने के लिए, आप a को a?: undefined रूप में घोषित कर सकते हैं, और टाइपस्क्रिप्ट खुश होंगे यदि आप इसे छोड़ देते हैं।

यदि मैं टिप्पणियों को सही ढंग से समझता हूं, तो यह काम करना चाहिए (लेकिन फेंकता है; खेल के मैदान पर परीक्षण किया गया): क्या यह बग है या नहीं? 🤔

type LinkProps = {
    to: string;
    onClick?: undefined;
    // Link specific props:
    target: string;
}

type ButtonProps = {
    to?: undefined;
    onClick: Function;
    // Button specific props:
    disabled: boolean;
}

type ActionProps = LinkProps | ButtonProps;

const Action = (props: ActionProps) =>
    props.to ?
        'Link with target: ' + props.target // Error not on ButtonProps
    :
        'Button with disabled: ' + props.disabled; // Error: not on LinkProps

Action({
  to: 'dssd',
  target: '_blank'
});

मुझे यह बिल्कुल समझ में नहीं आता है। यदि (A.a) का उपयोग करने के लिए if ((<A>AorB).a) समान नहीं है क्योंकि आप A वापस टाइप करने के लिए मजबूर कर रहे हैं?

यदि आप B को a: undefined परिभाषित करते हैं, तो आपको एक चर बनाते / पास करते समय इसे undefined पर सेट करना होगा।
उस के आसपास पाने के लिए, आप a को a?: undefined रूप में घोषित कर सकते हैं, और टाइपस्क्रिप्ट खुश होंगे यदि आप इसे छोड़ देते हैं।

बेहतर हो सकता है a?: never , अब आप गलती से undefined असाइन नहीं कर सकते

यदि आप संघ के प्रत्येक सदस्य को कोई नाम नहीं देते हैं, तो क्या होगा? (जैसा कि मुखर प्रकार के लिए एक नाम के बिना मैं कर सकता हूँ, क्या मैं ऊपर टाइप कर सकता हूँ?)

type u = "str" | {prop:"val"};
function f(arg:u){return arg.prop} // TypeScript: Property 'prop' does not exist on type 'u'

कोई भी समाधान?

मुझे पुस्तक पर एक समाधान मिल गया है:

interface A { x:  number;} 
interface B { y:  string;}
function doStuff ( q: A | B ) {
  if ( 'x'  in q) {
    //  if type A...
  }
  else {
    // if type B...
  }
}

अंश: बसरत अली सैयद "टाइपस्क्रिप्ट डीप डाइव।" Apple पुस्तकें।

एक वस्तु पर एक संपत्ति और एक प्रकार के गार्ड के रूप में इस्तेमाल किया जा सकता है, और टाइपस्क्रिप्ट यह जान सकता है कि आपने किस प्रकार का उपयोग किया।

type ColorItemType = {
    colorId: number,
    colorName: string,
}

type NumItemType = {
    numId: number,
    numName: string
}

type ResType = {
    itemId: number,
    // 0 color 1 num
    type: number,
    itemInfo: {
        colorList: Array<ColorItemType>
        numList: Array<NumItemType>
    }
}

const request = () => {
    return [{
        itemId: 1,
        type: 0,
        itemInfo: {
            colorList: [{
                colorId: 1,
                colorName: 'blue'
            }],
            numList: []
        }
    }];
};

const dataSource: Array<ResType> = request();

const formatData = dataSource.map(dataItem => {
    const list: Array<ColorItemType | NumItemType> = dataItem.type === 1 ? dataItem.itemInfo.numList : dataItem.itemInfo.colorList;
    return list.map(listItem => {
        return {
            // An error will be reported here
            value: listItem.numId || listItem.colorId,
            label: listItem.numName || listItem.colorName
        };
    });
});

यहाँ मुद्दा यह है कि क्योंकि B a संपत्ति की घोषणा नहीं करता है, यह रन-टाइम पर किसी भी संभावित प्रकार के a संपत्ति हो सकता है (क्योंकि आप एक असाइन कर सकते हैं गुणों के किसी भी सेट के साथ वस्तु B रूप में लंबे समय के रूप में यह b प्रकार की स्ट्रिंग की संपत्ति है)। आप यह स्पष्ट रूप से एक की घोषणा काम कर सकते हैं a: undefined में संपत्ति B (इस प्रकार सुनिश्चित करना है कि B कुछ यादृच्छिक नहीं होगा a संपत्ति):

type A = { a: string; } 
type B = { b: string; a: undefined }
type AorB = A | B;

declare const AorB: AorB;

if (AorB.a) {
    // Ok
}

मेरे लिए काम नहीं करता है 07.10.2020

और मुझे लगता है कि टीएस का यह व्यवहार अच्छा नहीं है क्योंकि यह एक डेवलपर की बहुत मदद नहीं करता है ...