टाइपस्क्रिप्ट: टाइप 'स्ट्रिंग' के पैरामीटर के साथ कोई इंडेक्स हस्ताक्षर टाइप '{"ए" पर नहीं पाया गया: स्ट्रिंग; }

Question 1

मेरे पास कुछ वेनिला जावास्क्रिप्ट कोड है जो एक स्ट्रिंग इनपुट लेता है, स्ट्रिंग को वर्णों में विभाजित करता है, और फिर उन वर्णों को एक वस्तु पर एक कुंजी से जोड़ता है।

DNATranscriber = {
    "G":"C",
    "C": "G",
    "T": "A",
    "A": "U"
}
function toRna(sequence){
    const sequenceArray = [...sequence];
    const transcriptionArray = sequenceArray.map(character =>{
        return this.DNATranscriber[character];
    });

    return transcriptionArray.join("");
}

console.log(toRna("ACGTGGTCTTAA")); //Returns UGCACCAGAAUU

यह उम्मीद के मुताबिक काम करता है। अब मैं इसे टाइपस्क्रिप्ट में बदलना चाहता हूं।

class Transcriptor {
    DNATranscriber = {
       G:"C",
       C: "G",
       T: "A",
       A: "U"
    }
    toRna(sequence: string) {
        const sequenceArray = [...sequence];
        const transcriptionArray = sequenceArray.map(character =>{
            return this.DNATranscriber[character];
        });
    }
}

export default Transcriptor

लेकिन मुझे निम्नलिखित त्रुटि मिल रही है।

तत्व का स्पष्ट रूप से एक 'कोई' प्रकार है क्योंकि 'स्ट्रिंग' प्रकार की अभिव्यक्ति का उपयोग अनुक्रमणिका प्रकार '{"ए" के लिए नहीं किया जा सकता है: स्ट्रिंग; } '। टाइप> 'स्ट्रिंग' के पैरामीटर के साथ कोई इंडेक्स सिग्नेचर टाइप नहीं मिला> '{"ए": स्ट्रिंग; } '। ts (7053)

मुझे लगा कि मुद्दा यह था कि मुझे एक स्ट्रिंग होने के लिए अपनी ऑब्जेक्ट कुंजी की आवश्यकता थी। लेकिन उन्हें तार में परिवर्तित करने से काम नहीं चला।

DNATranscriber = {
       "G":"C",
       "C": "G",
       "T": "A",
       "A": "U"
    }

मैं इससे काफी भ्रमित हूं। इसमें कहा गया है कि एक प्रकार का स्ट्रिंग वाला कोई सूचकांक हस्ताक्षर मेरी वस्तु पर मौजूद नहीं है। लेकिन मुझे यकीन है कि यह करता है। मैं क्या गलत कर रहा हूं?

संपादित करें - मैंने इसे DNATranscriber ऑब्जेक्ट को किसी भी प्रकार का हल देकर हल किया है।

DNATranscriber: any = {
    "G":"C",
    "C":"G",
    "T":"A",
    "A":"U"
}

Question 2

आप अपने इनपुट को मान्य करके त्रुटियों को ठीक कर सकते हैं, जो कुछ ऐसा है जिसे आपको निश्चित रूप से करना चाहिए।

निम्न रख-रखाव सही ढंग से, प्रकार की सुरक्षा मान्यताओं के माध्यम से

const DNATranscriber = {
    G: 'C',
    C: 'G',
    T: 'A',
    A: 'U'
};
export default class Transcriptor {
    toRna(sequence: string) {
        const sequenceArray = [...sequence];
        if (!isValidSequence(sequenceArray)) {
            throw Error('invalid sequence');
        }
        const transcribedRNA = sequenceArray.map(codon => DNATranscriber[codon]);
        return transcribedRNA;
    }
}

function isValidSequence(codons: string[]): codons is Array<keyof typeof DNATranscriber> {
    return codons.every(isValidCodon);
}
function isValidCodon(value: string): value is keyof typeof DNATranscriber {
    return value in DNATranscriber;
}

यहाँ एक अधिक मुहावरेदार संस्करण है

enum DNATranscriber {
    G = 'C',
    C = 'G',
    T = 'A',
    A = 'U'
}
export default function toRna(sequence: string) {
    const sequenceArray = [...sequence];
    if (!isValidSequence(sequenceArray)) {
        throw Error('invalid sequence');
    }
    const transcribedRNA = sequenceArray.map(codon => DNATranscriber[codon]);
    return transcribedRNA;
}

function isValidSequence(values: string[]): codons is Array<keyof typeof DNATranscriber> {
    return values.every(isValidCodon);
}
function isValidCodon(value: string): value is keyof typeof DNATranscriber {
    return value in DNATranscriber;
}

ध्यान दें कि हम स्पष्टता में सुधार करने और बेस जोड़ी मैपिंग के मजबूत टाइपिंग हासिल करने के लिए टाइपस्क्रिप्ट स्ट्रिंग एन्यूमरेशन का लाभ कैसे उठाते हैं। इससे भी महत्वपूर्ण बात, नोटिस करें कि हम कैसे उपयोग करते हैं function। यह महत्वपूर्ण है! जावास्क्रिप्ट को टाइपस्क्रिप्ट में परिवर्तित करने का कक्षाओं के साथ कोई लेना-देना नहीं है, इसे स्थैतिक प्रकारों के साथ करना है।

अपडेट :

टाइपस्क्रिप्ट 3.7 के बाद से, हम इसे और अधिक स्पष्ट रूप से लिख सकते हैं, इनपुट सत्यापन के बीच पत्राचार को औपचारिक रूप दे सकते हैं और मुखर हस्ताक्षर का उपयोग करके इसके प्रकार निहितार्थ कर सकते हैं ।

enum DNATranscriber {
    G = 'C',
    C = 'G',
    T = 'A',
    A = 'U'
}
export default function toRna(sequence: string) {
    const sequenceArray = [...sequence];
    validateSequence(sequenceArray);
    const transcribedRNA = sequenceArray.map(codon => DNATranscriber[codon]);
    return transcribedRNA;
}

function validateSequence(values: string[]): asserts codons is Array<keyof typeof DNATranscriber> {
    if (!values.every(isValidCodon)) {
        throw Error('invalid sequence');    
    }
}
function isValidCodon(value: string): value is keyof typeof DNATranscriber {
    return value in DNATranscriber;
}

आप के बारे में अधिक पढ़ सकते हैं अभिकथन हस्ताक्षर में टाइपप्रति 3.7 रिलीज नोट्स ।

Question 3

इसके अलावा, आप यह कर सकते हैं:

(this.DNATranscriber as any)[character];

संपादित करें।

यह अत्यधिक अनुशंसा की जाती है कि आप ऑब्जेक्ट को इसके बजाय उचित प्रकार के साथ कास्ट करें any। किसी ऑब्जेक्ट को कास्टिंग करना anyकेवल टाइप टाइप को संकलित करने में आपको त्रुटियों से बचने में मदद करता है, लेकिन यह आपके कोड को सुरक्षित रखने में आपकी मदद नहीं करता है।

उदाहरण के लिए

interface DNA {
    G:"C",
    C: "G",
    T: "A",
    A: "U"
}

और फिर आपने इसे इस तरह डाला:

(this.DNATranscriber as DNA)[character];

Question 4

यह मैंने अपनी संबंधित समस्या को हल करने के लिए किया था

interface Map {
  [key: string]: string | undefined
}

const HUMAN_MAP: Map = {
  draft: "Draft",
}

export const human = (str: string) => HUMAN_MAP[str] || str

Question 5

कोई उपयोग न करें, जेनरिक का उपयोग करें

// bad
const _getKeyValue = (key: string) => (obj: object) => obj[key];
    
// better
const _getKeyValue_ = (key: string) => (obj: Record<string, any>) => obj[key];
    
// best
const getKeyValue = <T extends object, U extends keyof T>(key: U) => (obj: T) =>
      obj[key];

ख़राब - त्रुटि का कारण यह है कि objectडिफ़ॉल्ट रूप से प्रकार केवल एक खाली वस्तु है। इसलिए एक stringप्रकार का अनुक्रमणिका का उपयोग करना संभव नहीं है {}।

बेहतर - कारण गायब हो जाता है क्योंकि अब हम संकलक को बता रहे हैं कि objतर्क स्ट्रिंग / मान ( string/any) जोड़े का संग्रह होगा । हालाँकि, हम इसका उपयोग कर रहे हैंany प्रकार , इसलिए हम बेहतर कर सकते हैं।

श्रेष्ठ - Tखाली वस्तु का विस्तार। Uकी चाबी निकालता है T। इसलिए Uहमेशा मौजूद रहेगा T, इसलिए इसे लुक अप मूल्य के रूप में इस्तेमाल किया जा सकता है।

यहाँ एक पूर्ण उदाहरण है:

मैंने जेनरिक के क्रम को बदल दिया है ( U extends keyof Tअब पहले आता है T extends object) यह उजागर करने के लिए कि जेनेरिक का आदेश महत्वपूर्ण नहीं है और आपको एक ऐसे आदेश का चयन करना चाहिए जो आपके कार्य के लिए सबसे अधिक समझ में आता है।

const getKeyValue = <U extends keyof T, T extends object>(key: U) => (obj: T) =>
  obj[key];

interface User {
  name: string;
  age: number;
}

const user: User = {
  name: "John Smith",
  age: 20
};

const getUserName = getKeyValue<keyof User, User>("name")(user);

// => 'John Smith'

वैकल्पिक वाक्य रचना

const getKeyValue = <T, K extends keyof T>(obj: T, key: K): T[K] => obj[key];

Question 6

मैंने अपने getClassफंक्शन में इसी तरह के मुद्दे को हल किया :

import { ApiGateway } from './api-gateway.class';
import { AppSync } from './app-sync.class';
import { Cognito } from './cognito.class';

export type stackInstances = typeof ApiGateway | typeof  AppSync | typeof Cognito

export const classes = {
  ApiGateway,
  AppSync,
  Cognito
} as {
  [key: string]: stackInstances
};

export function getClass(name: string) {
  return classes[name];
}

मेरे लिखने से classesमेरी संघ प्रकार के साथ स्थिरांक टाइपप्रति खुश कर दिया और यह मेरे लिए समझ में आता है।

Question 7

आपके पास सरल और मुहावरेदार टाइपस्क्रिप्ट के साथ दो विकल्प हैं:

सूचकांक प्रकार का उपयोग करें

DNATranscriber: { [char: string]: string } = {
  G: "C",
  C: "G",
  T: "A",
  A: "U",
};

यह सूचकांक हस्ताक्षर है त्रुटि संदेश के बारे में बात कर रहा है। संदर्भ

प्रत्येक संपत्ति टाइप करें:

DNATranscriber: { G: string; C: string; T: string; A: string } = {
  G: "C",
  C: "G",
  T: "A",
  A: "U",
};

Question 8

मैं थोड़ी देर के लिए इसके साथ खिलवाड़ किया। यहाँ मेरा परिदृश्य था:

मेरे पास दो प्रकार हैं, मेट्रिक्स 1 और मेट्रिक्स 2, प्रत्येक में अलग-अलग गुण हैं:

type metrics1 = {
    a: number;
    b: number;
    c: number;
}

type metrics2 = {
    d: number;
    e: number;
    f: number;
}

मेरे कोड में एक बिंदु पर, मैंने एक ऑब्जेक्ट बनाया जो इन दो प्रकारों का प्रतिच्छेदन है क्योंकि यह ऑब्जेक्ट उनके सभी गुणों को रखेगा:

const myMetrics: metrics1 & metrics2 = {
    a: 10,
    b: 20,
    c: 30,
    d: 40,
    e: 50,
    f: 60
};

अब, मुझे उस वस्तु के गुणों को गतिशील रूप से संदर्भित करने की आवश्यकता है। यह वह जगह है जहां हम सूचकांक हस्ताक्षर त्रुटियों में भाग लेते हैं। संकलन-समय जाँच और रनटाइम जाँच के आधार पर समस्या का हिस्सा टूट सकता है । मैं वस्तु को संदर्भित एक का उपयोग कर स्थिरांक , मुझे लगता है कि त्रुटि नहीं देखेंगे क्योंकि टाइपप्रति जांच कर सकते हैं संपत्ति संकलन समय के दौरान मौजूद है:

const myKey = 'a';
console.log(myMetrics[myKey]); // No issues, TypeScript has validated it exists

यदि, हालांकि, मैं एक गतिशील चर (जैसे चलो ) का उपयोग कर रहा हूं , तो टाइपस्क्रिप्ट यह जांचने में सक्षम नहीं होगा कि क्या संपत्ति संकलन समय के दौरान मौजूद है, और रनटाइम के दौरान अतिरिक्त मदद की आवश्यकता होगी। यह वह जगह है जहाँ निम्न प्रकार का गार्ड आता है:

function isValidMetric(prop: string, obj: metrics1 & metrics2): prop is keyof (metrics1 & metrics2) {
    return prop in obj;
}

यह के रूप में लिखा है, "यदि obj है संपत्ति प्रोप तो टाइपप्रति जानते हैं कि चलो प्रोप metrics1 और metrics2 के चौराहे में मौजूद है।" नोट : सुनिश्चित करें कि आप ऊपर दिखाए गए अनुसार keyof के बाद कोष्ठक में मेट्रिक्स 1 और मेट्रिक्स 2 को घेर लेते हैं , या फिर आप मेट्रिक्स 1 की कुंजी और मैट्रिक्स 2 (इसकी कुंजी नहीं) के बीच एक चौराहे के साथ समाप्त हो जाएंगे।

अब, मैं टाइपगार्ड का उपयोग कर सकता हूं और रनटाइम के दौरान सुरक्षित रूप से अपनी वस्तु तक पहुंच सकता हूं:

let myKey:string = '';
myKey = 'a';
if (isValidMetric(myKey, myMetrics)) {
    console.log(myMetrics[myKey]);
}

Question 9

Google के लिए:

प्रकार 'स्ट्रिंग' के एक पैरामीटर के साथ कोई सूचकांक हस्ताक्षर टाइप पर नहीं मिला ...

सबसे अधिक संभावना है कि आपकी त्रुटि को पढ़ना चाहिए:

क्या आप keyof Number इसके बजाय एक और अधिक विशिष्ट प्रकार का उपयोग करने का मतलब है string?

मैंने इस तरह के कोड के साथ एक समान टाइपिंग इश्यू हल किया:

const stringBasedKey = `SomeCustomString${someVar}` as keyof typeof YourTypeHere;

इस समस्या ने मुझे त्रुटि का वास्तविक अर्थ जानने में मदद की।

Question 10

ऐसा करके समस्या को हल किया:

export interface IItem extends Record<string, any> {
    itemId: string;
    price: number;
}

const item: IItem = { itemId: 'someId', price: 200 };
const fieldId = 'someid';

// gives you no errors and proper typing
item[fieldId]

Question 11

ऐसे ही मामलों से जूझ रहे किसी के लिए भी

No index signature with a parameter of type 'string' was found on type X

साधारण वस्तुओं के साथ इसका उपयोग करने की कोशिश कर रहा है ( जैसे dicts के रूप में प्रयुक्त ):

DNATranscriber = {
   G:"C",
   C: "G",
   T: "A",
   A: "U"
}

और गणना की गई कुंजी से मूल्य को गतिशील रूप से एक्सेस करने की कोशिश कर रहा है:

const key = getFirstType(dnaChain);
const result = DNATranscriber[key];

और आपने ऊपर दिखाए गए अनुसार त्रुटि का सामना किया, आप कीऑफ़ ऑपरेटर का उपयोग कर सकते हैं और कुछ ऐसा प्रयास कर सकते हैं

const key = getFirstType(dnaChain) as keyof typeof DNATranscriber;

निश्चित रूप से आपको एक गार्ड की आवश्यकता होगी, resultलेकिन अगर यह कुछ कस्टम प्रकार के जादू से अधिक सहज लगता है, तो यह ठीक है।

Question 12

यह त्रुटि को समाप्त करेगा और सुरक्षित है:

this.DNATranscriber[character as keyof typeof DNATranscriber]

Question 13

यहाँ फ़ंक्शन उदाहरण ट्रिम जेनेरिक प्रकार ट्रिम ऑब्जेक्ट है

const trimArrayObject = <T>(items: T[]) => {

  items.forEach(function (o) {

    for (let [key, value] of Object.entries(o)) {

      const keyName = <keyof typeof o>key;

      if (Array.isArray(value)) {

        trimArrayObject(value);

      } else if (typeof o[keyName] === "string") {

        o[keyName] = value.trim();

      }

    }

  });

};