typescript - टाइपस्क्रिप्ट में रिकॉर्ड प्रकार क्या है?




typescript2.0 (2)

टाइपस्क्रिप्ट में Record<K, T> क्या है?

टाइपस्क्रिप्ट 2.1 ने एक उदाहरण में वर्णन करते हुए Record प्रकार पेश किया:

// For every properties K of type T, transform it to U
function mapObject<K extends string, T, U>(obj: Record<K, T>, f: (x: T) => U): Record<K, U>

टाइपस्क्रिप्ट 2.1 देखें

और उन्नत प्रकार के पृष्ठ में Readonly , Partial और Pick साथ मैप किए गए प्रकारों के तहत Record का उल्लेख है, जो इसकी परिभाषा प्रतीत होती है:

type Record<K extends string, T> = {
    [P in K]: T;
}

आंशिक रूप से, आंशिक और पिक होमोमोर्फिक हैं जबकि रिकॉर्ड नहीं है। एक सुराग जो रिकॉर्ड होमोमोर्फिक नहीं है, वह यह है कि गुणों से कॉपी करने के लिए इनपुट प्रकार नहीं लिया जाता है:

type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>

और बस। उपरोक्त उद्धरणों के अलावा, typescriptlang.org पर Record का कोई अन्य उल्लेख नहीं है।

प्रशन

  1. क्या कोई सरल परिभाषा दे सकता है कि Record क्या है?

  2. क्या Record<K,T> केवल कहने का एक तरीका है "इस वस्तु पर सभी गुणों में टाइप T " होगा? संभवतः सभी गुण नहीं, क्योंकि K का कुछ उद्देश्य है ...

  3. क्या K जिस वस्तु पर K नहीं है, उस पर K जेनेरिक ने अतिरिक्त चाबियाँ मनाई हैं, या यह उन्हें अनुमति नहीं देता है और केवल यह संकेत देता है कि उनके गुण T रूपांतरित नहीं हुए हैं?

  4. दिए गए उदाहरण के साथ:

    type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>

    क्या यह वास्तव में ऐसा ही है ?:

    type ThreeStringProps = {prop1: string, prop2: string, prop3: string}

  1. क्या कोई सरल परिभाषा दे सकता है कि Record क्या है?

एक Record<K, T> एक वस्तु प्रकार है जिसकी संपत्ति कुंजी के हैं और जिनके संपत्ति मूल्य T । अर्थात keyof Record<K, T> के बराबर है, और Record<K, T>[K] के (मूल रूप से) T बराबर है।

  1. क्या Record<K,T> केवल कहने का एक तरीका है "इस वस्तु पर सभी गुणों में टाइप T " होगा? संभवतः सभी ऑब्जेक्ट नहीं हैं, क्योंकि K का कुछ उद्देश्य है ...

जैसा कि आप ध्यान दें, K का एक उद्देश्य है ... संपत्ति कुंजी को विशेष मूल्यों तक सीमित करना। यदि आप सभी संभावित स्ट्रिंग-वैल्यू कीज़ को स्वीकार करना चाहते हैं, तो आप Record<string, T> जैसे कुछ कर सकते हैं, लेकिन ऐसा करने का मुहावरेदार तरीका { [k: string]: T } जैसे इंडेक्स सिग्नेचर का उपयोग करना है।

  1. क्या K जिस वस्तु पर K नहीं है, उस पर K जेनेरिक ने अतिरिक्त चाबियाँ मनाई हैं, या यह उन्हें अनुमति नहीं देता है और केवल यह संकेत देता है कि उनके गुण T रूपांतरित नहीं हुए हैं?

यह अतिरिक्त कुंजियों को "निषिद्ध" बिल्कुल नहीं करता है: आखिरकार, एक मूल्य को आमतौर पर अपने प्रकार में स्पष्ट रूप से उल्लेखित नहीं होने वाले गुणों की अनुमति होती है ... लेकिन यह नहीं पहचानता है कि ऐसे गुण मौजूद हैं:

declare const x: Record<"a", string>;
x.b; // error, Property 'b' does not exist on type 'Record<"a", string>'

और यह उन्हें अतिरिक्त गुणों के रूप में मानता है जिन्हें कभी-कभी अस्वीकार कर दिया जाता है:

declare function acceptR(x: Record<"a", string>): void;
acceptR({a: "hey", b: "you"}); // error, Object literal may only specify known properties

और कभी-कभी स्वीकार किया जाता है:

const y = {a: "hey", b: "you"};
acceptR(y); // okay
  1. दिए गए उदाहरण के साथ:

    type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>

    क्या यह वास्तव में ऐसा ही है ?:

    type ThreeStringProps = {prop1: string, prop2: string, prop3: string}

हाँ!

उम्मीद है की वो मदद करदे। सौभाग्य!


एक रिकॉर्ड आपको संघ से एक नया प्रकार बनाने की सुविधा देता है। संघ में मूल्यों का उपयोग नए प्रकार की विशेषताओं के रूप में किया जाता है।

उदाहरण के लिए, मान लीजिए कि मेरे पास एक संघ है:

type CatNames = "miffy" | "boris" | "mordred";

अब मैं एक ऐसी वस्तु बनाना चाहता हूं जिसमें सभी बिल्लियों के बारे में जानकारी हो, मैं कुंजियों के संघ में मानों का उपयोग करके एक नया प्रकार बना सकता हूं।

type CatList = Record<CatNames, {age: number}>

यदि मैं इस कैटालिस्ट को संतुष्ट करना चाहता हूं, तो मुझे इस तरह से एक ऑब्जेक्ट बनाना होगा:

const cats:CatList = {
  miffy: { age:99 },
  boris: { age:16 },
  mordred: { age:600 }
}

आपको बहुत मजबूत प्रकार की सुरक्षा मिलती है:

  • यदि मैं एक बिल्ली को भूल जाता हूं, तो मुझे एक त्रुटि मिलती है।
  • यदि मैं एक बिल्ली जोड़ता हूं जिसकी अनुमति नहीं है, तो मुझे एक त्रुटि मिलती है।
  • यदि मैं बाद में कैटनेम बदल देता हूं, तो मुझे एक त्रुटि मिलती है। यह विशेष रूप से उपयोगी है क्योंकि CatNames को संभवतः किसी अन्य फ़ाइल से आयात किया जाता है, और संभवतः कई स्थानों पर उपयोग किया जाता है।

वास्तविक दुनिया प्रतिक्रिया उदाहरण।

मैंने हाल ही में एक स्थिति घटक बनाने के लिए इसका उपयोग किया था। घटक को एक स्थिति प्रोप प्राप्त होगा, और फिर एक आइकन प्रस्तुत करना होगा। मैंने चित्रण के उद्देश्य से यहां कोड को काफी सरल बना दिया है

मेरा संघ इस तरह था:

type Statuses = "failed" | "complete";

मैंने इसका उपयोग इस तरह एक वस्तु बनाने के लिए किया है:

const icons: Record<
  Statuses,
  { iconType: IconTypes; iconColor: IconColors }
> = {
  failed: {
    iconType: "warning",
    iconColor: "red"
  },
  complete: {
    iconType: "check",
    iconColor: "green"
  };

मैं तब वस्तु से एक तत्व को प्रॉप्स में नष्ट करके प्रस्तुत कर सकता था, जैसे:

const Status = ({status}) => <Icon {...icons[status]} />

यदि स्टेटस यूनियन बाद में विस्तारित या परिवर्तित हो जाता है, तो मुझे पता है कि मेरा स्टेटस कंपोनेंट संकलन में विफल हो जाएगा और मुझे एक त्रुटि मिलेगी जिसे मैं तुरंत ठीक कर सकता हूं। यह मुझे एप्लिकेशन में अतिरिक्त त्रुटि राज्यों को जोड़ने की अनुमति देता है।

ध्यान दें कि वास्तविक ऐप में दर्जनों त्रुटि राज्य थे जिन्हें कई स्थानों पर संदर्भित किया गया था, इसलिए इस प्रकार की सुरक्षा बेहद उपयोगी थी।





typescript2.0