मेरे पास निम्न कोड है:

type PartialRecord<K extends keyof any, T> = {
  [P in K]?: T;
};

export class CustomMaps {
  public static createInnerMap<T, K extends keyof any>(array: T[], customKey: keyof T): PartialRecord<K, T> {
    const innerMap: PartialRecord<K, T> = {};
    for (let i = 0; i < array.length; ++i) {
      innerMap[array[i][customKey] as K] = array[i];
    }
    return innerMap;
  }
}

यह त्रुटि देता है: 'T[keyof T]' प्रकार का 'K' टाइप करने के लिए रूपांतरण एक गलती हो सकती है क्योंकि न तो टाइप पर्याप्त रूप से दूसरे के साथ ओवरलैप करता है। यदि यह जानबूझकर किया गया था, तो पहले अभिव्यक्ति को 'अज्ञात' में बदलें।

यह क्या करना चाहिए यह है:

  class Car {
    private color: string;
    private wheelcount: number;
    constructor(color: string, wheelcount: number) {
      this.color = color;
      this.wheelcount = wheelcount;
    }
  }
  const redCar = new Car('red', 4);
  const blueCar = new Car('blue', 8);
  const yellowCar = new Car('yellow', 6);
  const colorMap = CustomMaps.createInnerMap<Car, string>([redCar, blueCar, yellowCar], 'color');
  colorMap['red'] // should return redCar instance

  const wheelMap = CustomMaps.createInnerMap<Car, number>([redCar, blueCar, yellowCar], 'wheelcount');
  wheelMap[8] // should return blueCar instance

इनरमैप [सरणी [i] [कस्टमकी]] को अज्ञात में कास्ट किए बिना, मैं यह कैसे सुनिश्चित कर सकता हूं कि सरणी [i] [कस्टमकी] एक प्रकार लौटाएगा जिसका उपयोग अनुक्रमण के लिए किया जा सकता है (विशेष रूप से जिस प्रकार मैं के लिए स्थानापन्न करता हूं)?

1
CoderApprentice 30 जून 2020, 21:24

1 उत्तर

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

ऐसा प्रतीत होता है कि मैंने "के रूप में अज्ञात के रूप में" कास्टिंग के गंदे फिक्स का उपयोग किए बिना समाधान ढूंढ लिया है।

मैंने ये कस्टम प्रकार बनाए हैं:

type TRecordKey = string | number | symbol;
type TRecurringRecord<K extends T[keyof T] & TRecordKey, T> = {
  [P in K]?: T
}

फिर मैंने उपरोक्त कोड को इस तरह समायोजित किया:

  public static recurringMap<K extends T[keyof T] & TRecordKey, T>(
    array: T[],
    customKey: keyof T
  ): TRecurringRecord<K, T> {
    const recurringMap: TRecurringRecord<K, T> = {};
    for (let i = 0; i < array.length; ++i) {
      recurringMap[array[i][customKey] as K] = array[i];
    }
    return recurringMap;
  }

अब हमारे पास एक सामान्य कार्य है जो वस्तुओं का एक नक्शा बनाता है जहां उस मानचित्र की कुंजियाँ वस्तु की ही एक संपत्ति होती हैं।

0
CoderApprentice 20 जुलाई 2020, 15:40