कंपोनेंट जेनेरिक — परिचय
टाइप पैरामीटर, बाधाओं और अनुमान के साथ पुनः-उपयोग योग्य कंपोनेंट बनाएँ; टाइप किए गए render props और keys सुरक्षित रूप से पास करें।
कंपोनेंट जेनेरिक — परिचय, CoddyKit पर TypeScript Academy का एक निःशुल्क पाठ है। यह 3 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह TypeScript Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। TypeScript Academy पाठ्यक्रम में कुल 3 पाठ शामिल हैं।
परिचय
लक्ष्य: <T> का उपयोग करके ऐसा एक घटक बनाएँ जो कई डेटा आकारों के साथ काम करे। आप टाइप किया हुआ रेंडर प्रॉप पास करेंगे, कुंजियों को सीमित करेंगे और उपयोग के आधार पर TypeScript को T का अनुमान लगाने देंगे।
- जेनेरिक प्रॉप्स और रेंडर फ़ंक्शन
extendsसे सीमाएँ- किसी भी प्रकार के बिना कुंजी निकालना
जेनेरिक सूची<T>
जेनेरिक List<T> आइटम और रेंडर को एक-दूसरे के अनुरूप रखती है। उपयोगकर्ता कोई भी T पास कर सकते हैं; जब T स्पष्ट हो, तो अनुमान काम करता है।
import React from "react"
type ListProps<T> = { items: T[]; render: (item: T, index: number) => React.ReactNode }
export function List<T>({ items, render }: ListProps<T>) {
return <div style={{ display: "grid", gap: 6 }}>{items.map(render)}</div>
}
export default function App() {
return (
<div style={{ display: "grid", gap: 12 }}>
<List<number> items={[1,2,3]} render={(n) => <span>#{n}</span>} />
<List<{ id: string; name: string }>
items={[{ id: "u1", name: "Ada" }, { id: "u2", name: "Lin" }]}
render={(u) => <strong>{u.name}</strong>}
/>
</div>
)
}extends से सीमाएँ
कुंजियों के लिए id आवश्यक करने हेतु T extends Keyed का उपयोग करें। आवश्यक फ़ील्ड के बिना आइटम पास करने पर कॉल करने वाले को त्रुटियाँ मिलेंगी।
import React from "react"
type Keyed = { id: string }
type KeyListProps<T extends Keyed> = { items: T[]; render: (item: T) => React.ReactNode }
export function KeyList<T extends Keyed>({ items, render }: KeyListProps<T>) {
return (
<ul>
{items.map((x) => (
<li key={x.id}>{render(x)}</li>
))}
</ul>
)
}
export default function App() {
const users = [{ id: "u1", name: "Ada" }, { id: "u2", name: "Lin" }]
return <KeyList items={users} render={(u) => <span>{u.name}</span>} />
}T का अनुमान
प्रकार पैरामीटर आम तौर पर प्रॉप्स से अनुमानित होते हैं: यहाँ T items से आता है। अनुमान अस्पष्ट होने पर ही एनोटेशन दें।
import React from "react"
type GridProps<T> = { items: T[]; columns?: number; render: (item: T) => React.ReactNode }
export function Grid<T>({ items, columns = 2, render }: GridProps<T>) {
const css = { display: "grid", gridTemplateColumns: `repeat(${columns}, 1fr)`, gap: 8 }
return <div style={css as React.CSSProperties}>{items.map(render)}</div>
}
export default function App() {
const products = [
{ sku: "p1", title: "Mouse", price: 25 },
{ sku: "p2", title: "Keyboard", price: 80 }
]
// T is inferred from products; no need to annotate
return <Grid items={products} render={(p) => <span>{p.title} — ${p.price}</span>} />
}रेंडर सहायक
स्पष्टता के लिए दोबारा उपयोग किए जा सकने वाले Render<T> प्रकार अलग निकालें। कुंजियों को समर्थित करने के लिए आवश्यक होने पर (T extends { id: string }) सीमा लगाएँ।
import React from "react"
type Render<T> = (item: T) => React.ReactNode
type TableProps<T extends { id: string }> = { items: T[]; renderRow: Render<T> }
export function Table<T extends { id: string }>({ items, renderRow }: TableProps<T>) {
return (
<table>
<tbody>
{items.map((x) => (
<tr key={x.id}><td>{renderRow(x)}</td></tr>
))}
</tbody>
</table>
)
}
export default function App() {
const rows = [ { id: "1", label: "One" }, { id: "2", label: "Two" } ]
return <Table items={rows} renderRow={(r) => <span>{r.label}</span>} />
}सुझाव और सावधानियाँ
सुझाव:
- अनुमान को प्राथमिकता दें; केवल पठनीयता में मदद मिलने पर एनोटेशन दें।
- आवश्यकताओं को व्यक्त करने के लिए
extendsसे सीमा लगाएँ। - जेनेरिक रेंडर प्रॉप्स में
anyसे बचें; इससे सुरक्षा समाप्त हो जाती है।
जेनेरिक घटक जाँच
त्वरित जाँच: जेनेरिक React घटक को सही ढंग से कौन-सी घोषणा परिभाषित करती है?
पुनरावलोकन
पुनरावलोकन: दोबारा उपयोग किए जा सकने वाले घटक बनाने के लिए <T> का उपयोग करें, कुंजियों के लिए extends से सीमा लगाएँ और कोड को संक्षिप्त रखने के लिए अनुमान पर निर्भर रहें।
एआई शिक्षक के साथ TypeScript सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 101
- पाठ
- 352
अक्सर पूछे जाने वाले प्रश्न
क्या “कंपोनेंट जेनेरिक — परिचय” पाठ निःशुल्क है?
हाँ—“कंपोनेंट जेनेरिक — परिचय” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और TypeScript Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। TypeScript Academy पाठ्यक्रम में कुल 3 पाठ शामिल हैं।
“कंपोनेंट जेनेरिक — परिचय” में मैं क्या सीखूँगा?
टाइप पैरामीटर, बाधाओं और अनुमान के साथ पुनः-उपयोग योग्य कंपोनेंट बनाएँ; टाइप किए गए render props और keys सुरक्षित रूप से पास करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ TypeScript Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या TypeScript Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर TypeScript Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 3 में से 3वाँ पाठ है।
“कंपोनेंट जेनेरिक — परिचय” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस TypeScript Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर TypeScript Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- प्रॉप्स और children; इवेंट हैंडलर; refs
- स्टेट और रिड्यूसर; Context टाइपिंग
- कंपोनेंट जेनेरिक — परिचय