TypeScript जेनरिक्सExplained

28 of 28 rows

पैटर्न↕	यह क्या करता है↕	उदाहरण↕
घोषित करें
⤢<T>	एक टाइप पैरामीटर जिसे कॉलर चुनता है।	function first<T>(xs: T[]): T
⤢<T, U>	कई स्वतंत्र टाइप पैरामीटर।	function pair<T, U>(a: T, b: U): [T, U]
⤢<T, K extends keyof T>	दूसरा पैरामीटर जो पहले की keys से बंधा है।	function get<T, K extends keyof T>(o: T, k: K): T[K]
⤢class Box<T>	ऐसी क्लास जिसके फ़ील्ड्स और मेथड्स पर टाइप पैरामीटर है।	class Box<T> { value: T }
⤢interface Result<T>	ऐसा ऑब्जेक्ट शेप जिसमें टाइप पैरामीटर हो।	interface Result<T> { data: T }
⤢<T,>	ऐरो फ़ंक्शन पर टाइप पैरामीटर; अंत में लगा कॉमा .tsx फ़ाइलों को इसे JSX समझने से रोकता है।	const first = <T,>(xs: T[]): T => xs[0]
सीमित करें
⤢T extends Type	अपेक्षा करता है कि T, Type को assignable हो।	function len<T extends { length: number }>(x: T)
⤢T extends keyof O	T को किसी दूसरे टाइप की key तक सीमित करता है।	type Keys<O> = keyof O
⤢new (...a) => T	T को ऐसी क्लास तक सीमित करता है जिसे new से बनाया जा सके।	function make<C extends new () => C>(c: C): C
⤢T extends A & B	अपेक्षा करता है कि T एक साथ कई constraints पूरे करे।	function log<T extends Error & { code: number }>(e: T)
⤢T extends unknown	किसी भी चीज़ तक सीमित; पैरामीटर को narrowing किए बिना generic रखता है।	type Wrap<T> = T extends unknown ? { v: T } : never
डिफ़ॉल्ट और infer
⤢<T = Default>	जब कॉलर इसे छोड़ देता है तो T को डिफ़ॉल्ट देता है।	function parse<T = string>(): T
⤢infer X	कंडीशनल के अंदर एक टाइप कैप्चर करता है।	type El<T> = T extends Array<infer I> ? I : never
⤢Awaited<T>	नेस्टेड Promise को उसके भीतरी टाइप तक खोलता है।	type Data = Awaited<Promise<User>>
⤢`${infer P}`	टेम्पलेट लिटरल टाइप का एक टुकड़ा कैप्चर करता है।	type Path<S> = S extends `/api/${infer R}` ? R : never
⤢[T] extends [X]	पूरे यूनियन को एक बार में जाँचता है; खुला T एक बार में एक मेंबर infer करता है।	type El<T> = [T] extends [Array<infer I>] ? I : never
कंडीशनल और मैप्ड
⤢T extends U ? X : Y	T के U को assignable होने या न होने के आधार पर टाइप चुनता है।	type IsStr<T> = T extends string ? true : false
⤢{ [K in keyof T]: ... }	T की हर key को बदलकर नया ऑब्जेक्ट टाइप बनाता है।	type Frozen<T> = { [K in keyof T]: Readonly<T[K]> }
⤢Record<K, V>	ऐसा ऑब्जेक्ट जिसकी keys हैं K और values हैं V।	type Scores = Record<string, number>
⤢Omit / Pick / Partial	ऊपर दिए पैटर्न से निकले बिल्ट-इन जेनरिक्स।	type Preview = Pick<User, "id" | "name">
⤢naked T	extends से पहले खुला T यूनियन के हर मेंबर पर एक बार चलता है और परिणामों को जोड़ देता है।	ToArray<'a' | 'b'> = 'a'[] | 'b'[]
⤢-? / -readonly	मैप की गई keys पर modifiers जोड़ता या हटाता है।	type Req<T> = { [K in keyof T]-?: T[K] }
⤢keyof typeof v	रनटाइम वैल्यू की keys, एक टाइप के रूप में।	const opts = { a: 1 }; type K = keyof typeof opts
⤢`${K}`	दूसरे स्ट्रिंग टाइप्स से स्ट्रिंग टाइप बनाता है।	type Route = `/users/${string}`
⤢[...T, ...U]	टुपल टाइप्स को आपस में जोड़ता है।	type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]
⤢type Tree<T>	ऐसा टाइप जिसकी परिभाषा खुद को ही रेफ़र करती है।	type Json = string | number | Json[] | { [k: string]: Json }
⤢satisfies	किसी वैल्यू को टाइप से जाँचता है और उसका संकरा लिटरल टाइप बनाए रखता है।	const c = { dark: "#000" } satisfies Record<string, string>
⤢<const T>	कॉलर के लिटरल टाइप को widen करने के बजाय बनाए रखता है (TS 5.0)।	function first<const T>(xs: readonly T[]): T