मेरे पास एक ऐसा फ़ंक्शन है जो फ़ंक्शन पैरामीटर के आधार पर विभिन्न ऑब्जेक्ट्स लौटाएगा। क्या कोई तरीका है कि मैं इसे टाइपस्क्रिप्ट में कैसे प्राप्त कर सकता हूं?

मुझे यह कितना दूर मिला है:

type returnMap = {
    'a': number,
    'b': string[]
}

function func<T extends returnMap, K extends keyof T>(val: K): T[K] {
    if (val == 'a') {return 5}
    if (val == 'b') {return ['a', 'b']}
    return 42
}
console.log(func('a'))  // 5

हालांकि, यह कहता है कि "TS2322: टाइप '5' रिटर्न वैल्यू पर 'टी [के]' टाइप करने के लिए असाइन करने योग्य नहीं है।

पहले ही, आपका बहुत धन्यवाद

1
Nayaro 8 जिंदा 2021, 10:21

3 जवाब

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

इससे चल जाएगा:

interface ReturnMap {
  'a': number;
  'b': string[];
}

function func<K extends keyof ReturnMap>(val: K): ReturnMap[K];
function func(val: keyof ReturnMap): ReturnMap[keyof ReturnMap] {
  if (val === 'a') return 5;
  if (val === 'b') return ['a', 'b'];
  throw new Error();
}

const r1 = func('a'); // const r1: number
const r2 = func('b'); // const r2: string[]

// Argument of type '"c"' is not assignable to parameter of type '"a" | "b"'.ts(2345)
const r3 = func('c'); // const r3: number | string[]

फ़ंक्शन ओवरलोडिंग सिंटैक्स पर ध्यान दें:

function func<K extends keyof ReturnMap>(val: K): ReturnMap[K];
function func(val: keyof ReturnMap): ReturnMap[keyof ReturnMap] { // ...

यदि आपने केवल दूसरे हस्ताक्षर का उपयोग किया है, तो लौटा हुआ प्रकार हमेशा number | string[] होगा।

यदि आपने केवल पहले हस्ताक्षर का उपयोग किया है, तो ReturnMap[K] का मूल्यांकन (फ़ंक्शन के शरीर के अंदर) number & string[] के रूप में किया जाता है, जो कि विरोधाभासी है, इसलिए आपको वे त्रुटियां मिलती हैं जिनका आपने ऊपर अपने प्रश्न में वर्णन किया है।

वैकल्पिक रूप से, यदि आप अतिभारित हस्ताक्षर का उपयोग नहीं करना चाहते हैं - तो आप परिणाम को फ़ंक्शन के शरीर के अंदर डाल सकते हैं:

function func<K extends keyof ReturnMap>(val: K): ReturnMap[K] {
  if (val === 'a') return 5 as ReturnMap[K];
  if (val === 'b') return ['a', 'b'] as ReturnMap[K];
  throw new Error();
}
3
Tomasz Gawel 10 जिंदा 2021, 05:24

मुझे लगता है कि ओवरलोडिंग आपकी मदद कर सकती है:

type returnMap = {
    'a': number,
    'b': string[],
    'x': 42,
    'z': 42,
}

function func<T extends returnMap, K extends Exclude<keyof returnMap,'a'|'b'>>(val: K): 42;
function func<T extends returnMap, K extends 'b'>(val: K): string[];
function func<T extends returnMap, K extends 'a'>(val: K): number;
function func<T extends returnMap, K extends keyof T>(val: K): number | string[] {
    if (val == 'a') {
        return 5
    }
    if (val == 'b') {
        return ['a', 'b']
    }
    return 42
}

const result = func('a') // number
const result1 = func('b') // string[]
const result2 = func('x') // 42
const result3 = func('z') // 42
1
captain-yossarian 8 जिंदा 2021, 10:49

यह any को लौटाए गए चर के प्रकार के रूप में उपयोग करने के लिए एक अच्छे उपयोग के मामले की तरह लगता है।

देखें https://www.typescriptlang.org/docs/handbook/basic -types.html#any.

-1
Shane Richards 8 जिंदा 2021, 10:27