अगर वहाँ की तरह परिभाषित किया गया है

type GroupIds = 'A'|'B'|'C'
type KeysA = 'A01' | 'A02'
type KeysB = 'B03' | 'B04'
type KeysC = 'C99'

मुझे पता है कि इसे इस प्रकार लिखा जा सकता है

function MethodBy( p0:'A', p1:KeysA )
function MethodBy( p0:'B', p1:KeysB )
function MethodBy( p0:'C', p1:KeysC )
function MethodBy( p0, p1 )
{
    //implement
}

लेकिन मैं पूछना चाहता हूं कि क्या ऐसा कुछ है

//maybe define a mapper
type IMapForKeys<T extends GroupIds> =
{
    [ key: 'A' ]: KeysA
    [ key: 'B' ]: KeysB
    [ key: 'C' ]: KeysC
}

//then method can write like...
function MethodBy<T extends GroupIds>( p0:T, p1:IMapForKeys[T] )
{
    //implement
}

या क्या कोई कामकाज है, संकेत मिलने की उम्मीद है, धन्यवाद :)

1
Raz 30 मार्च 2021, 09:25

2 जवाब

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

मुझे पता है कि निकटतम दृष्टिकोण GroupIds में मानों को IMapForKeys में कुंजियों के रूप में मैन्युअल रूप से उपयोग करना है।

type GroupIds = 'A' | 'B' | 'C'
type KeysA = 'A01' | 'A02'
type KeysB = 'B03' | 'B04'
type KeysC = 'C99'

type IMapForKeys = {
  'A': KeysA;
  'B': KeysB;
  'C': KeysC;
}

function MethodBy<T extends GroupIds>(p0: T, p1: IMapForKeys[T]) {}

MethodBy में उपयोग शब्दार्थ सही हैं।

MethodBy('D', 'A01') // 'D' not allowed
MethodBy('A', 'A01') // allowed
MethodBy('A', 'B03') // 'B03' not allowed

यदि GroupIds में एक नई कुंजी जोड़ी जाती है, तो MethodBy में दूसरा पैरामीटर Type 'T' cannot be used to index type 'IMapForKeys'. के साथ टाइप चेकिंग में विफल हो जाएगा।

यदि IMapForKeys में कोई अज्ञात कुंजी जोड़ी जाती है, तो आप इसे MethodBy में पहले पैरामीटर के रूप में उपयोग नहीं कर पाएंगे, क्योंकि इसके लिए GroupIds के सदस्य की आवश्यकता होती है।


यदि संभव हो, तो मेरा सुझाव है कि GroupIds और Keys प्रकारों को IMapForKeys से खींचने के बजाय, अन्य तरीकों से आपके प्रकारों का पुनर्गठन करें। मुझे लगता है कि यह क्लीनर है क्योंकि प्रकारों के लिए सच्चाई का एक ही स्रोत है।

interface IMapForKeys {
  'A': 'A01' | 'A02';
  'B': 'B03' | 'B04';
  'C': 'C99';
}

type GroupIds = keyof IMapForKeys
type KeysA = IMapForKeys['A']
type KeysB = IMapForKeys['B']
type KeysC = IMapForKeys['C']

function MethodBy<T extends GroupIds>(p0: T, p1: IMapForKeys[T]) {}

MethodBy('D', 'A01') // 'D' not allowed
MethodBy('A', 'A01') // allowed
MethodBy('A', 'B03') // 'B03' not allowed
0
Cameron Little 30 मार्च 2021, 06:40

एक संभावित समाधान भेदभाव वाली यूनियनों का उपयोग कर रहा है। यहाँ एक उदाहरण है:

type MyTypeA = {
    p0: "A";
    p1: 'A01' | 'A02';
}

type MyTypeB = {
    p0: "B";
    p1: 'B03' | 'B04';
}

type MyTypeC = {
    p0: "C";
    p1: 'C99';
}

function MethodBy(args: MyTypeA | MyTypeB | MyTypeC) {
    //
}

//e.g.
MethodBy({ p0: "B", p1: "B04" });   //OK
MethodBy({ p0: "B", p1: "C99" });   //compile error
0
Mario Vernari 30 मार्च 2021, 06:37