javascript एक ऐसी अभिव्यक्ति का आह्वान नहीं कर सकते हैं जिसके प्रकार में कॉल हस्ताक्षर की कमी है




typescript types (4)

मेरे पास सेब और नाशपाती है - दोनों में एक isDecayed विशेषता है:

interface Apple {
    color: string;
    isDecayed: boolean;
}

interface Pear {
    weight: number;
    isDecayed: boolean;
}

और दोनों प्रकार मेरे फलों की टोकरी (कई बार) में हो सकते हैं:

interface FruitBasket {
   apples: Apple[];
   pears: Pear[];
}

मान लीजिए कि अब मेरी टोकरी खाली है:

const fruitBasket: FruitBasket = { apples: [], pears: [] };

अब हम बेतरतीब ढंग से टोकरी से बाहर निकालते हैं:

const key: keyof FruitBasket = Math.random() > 0.5 ? 'apples': 'pears'; 
const fruits = fruitBasket[key];

और निश्चित रूप से कोई भी क्षय किए गए फलों को पसंद नहीं करता है, इसलिए हम केवल ताजा फल लेते हैं:

const freshFruits = fruits.filter((fruit) => !fruit.isDecayed);

दुर्भाग्य से टाइपस्क्रिप्ट मुझे बताता है:

एक ऐसी अभिव्यक्ति का आह्वान नहीं कर सकते हैं जिसके प्रकार में कॉल हस्ताक्षर की कमी है। प्रकार '((कॉलबैकफ़न: (मान: Apple, अनुक्रमणिका: संख्या, सरणी: Apple []) => कोई भी, यहAAg ?: कोई भी) => Apple [] | ... 'कोई संगत कॉल हस्ताक्षर नहीं है।

यहां क्या गलत है - क्या यह सिर्फ टाइपस्क्रिप्ट ताजे फलों को पसंद नहीं करता है या यह एक टाइपस्क्रिप्ट बग है?

आप इसे आधिकारिक टाइपस्क्रिप्ट रिप्ले में स्वयं आज़मा सकते हैं।


जैसा कि टिप्पणी में मूल रूप से @peter द्वारा लिंक किए गए गितुब github.com/Microsoft/TypeScript/issues/7960 में उल्लेख किया गया है:

const freshFruits = (fruits as (Apple | Pear)[]).filter((fruit: (Apple | Pear)) => !fruit.isDecayed);

टाइपस्क्रिप्ट संरचनात्मक टाइपिंग (जिसे डक टाइपिंग भी कहा जाता है) का समर्थन करता है, जिसका अर्थ है कि जब वे समान सदस्य साझा करते हैं तो प्रकार संगत होते हैं । आपकी समस्या यह है कि Apple और Pear अपने सभी सदस्यों को साझा नहीं करते हैं, जिसका अर्थ है कि वे संगत नहीं हैं। वे हालांकि एक अन्य प्रकार के अनुकूल हैं, जिसमें केवल isDecayed: boolean सदस्य हैं। संरचनात्मक टाइपिंग के कारण, आपको इस तरह के इंटरफ़ेस से Apple और Pear विरासत में लेने की जरूरत है।

इस तरह के संगत प्रकार को निर्दिष्ट करने के विभिन्न तरीके हैं:

वेरिएबल डिक्लेरेशन के दौरान टाइप करें

यह कथन स्पष्ट रूप से Apple[] | Pear[] लिए टाइप किया गया है Apple[] | Pear[] :

const fruits = fruitBasket[key];

आप अपनी चर घोषणा में स्पष्ट रूप से संगत प्रकार का उपयोग कर सकते हैं:

const fruits: { isDecayed: boolean }[] = fruitBasket[key];

अतिरिक्त पुन: प्रयोज्य के लिए, आप पहले प्रकार को परिभाषित कर सकते हैं और फिर अपनी घोषणा में इसका उपयोग कर सकते हैं (ध्यान दें कि Apple और Pear इंटरफेस को बदलने की आवश्यकता नहीं है):

type Fruit = { isDecayed: boolean };
const fruits: Fruit[] = fruitBasket[key];

ऑपरेशन के लिए संगत प्रकार के लिए कास्ट करें

दिए गए समाधान के साथ समस्या यह है कि यह fruits के प्रकार को बदलता है। यह वह नहीं हो सकता जो आप चाहते हैं। इससे बचने के लिए, आप ऑपरेशन से पहले सरणी को एक संगत प्रकार तक सीमित कर सकते हैं और फिर उसी प्रकार के fruits वापस सेट कर सकते fruits :

const fruits: fruitBasket[key];
const freshFruits = (fruits as { isDecayed: boolean }[]).filter(fruit => !fruit.isDecayed) as typeof fruits;

या पुन: प्रयोज्य Fruit प्रकार के साथ:

type Fruit = { isDecayed: boolean };
const fruits: fruitBasket[key];
const freshFruits = (fruits as Fruit[]).filter(fruit => !fruit.isDecayed) as typeof fruits;

इस समाधान का लाभ यह है कि fruits और freshFruits दोनों ही प्रकार के होते हैं Apple[] | Pear[] Apple[] | Pear[]


मैं अंक के साथ एक ही मुद्दा था, एक जेएस पुस्तकालय। इस आदेश के साथ फिर से टाइपिंग स्थापित करने के लिए फिक्स था:

npm install --save @types/numeral

शायद एक साझा Fruit इंटरफ़ेस बनाएँ जो प्रदान करता है isDecayed। fruits अब प्रकार के हैं Fruit[] इसलिए प्रकार स्पष्ट हो सकता है। ऐशे ही:

interface Fruit {
    isDecayed: boolean;
}

interface Apple extends Fruit {
    color: string;
}

interface Pear extends Fruit {
    weight: number;
}

interface FruitBasket {
    apples: Apple[];
    pears: Pear[];
}


const fruitBasket: FruitBasket = { apples: [], pears: [] };
const key: keyof FruitBasket = Math.random() > 0.5 ? 'apples': 'pears'; 
const fruits: Fruit[] = fruitBasket[key];

const freshFruits = fruits.filter((fruit) => !fruit.isDecayed);




types