TypeScript बड़े पैमाने पर वेब विकास के लिए उद्योग मानक बन गया है। जबकि अधिकांश डेवलपर्स इंटरफेस और प्रकारों की मूल बातें जानते हैं, वास्तविक शक्ति इसके उन्नत प्रकार प्रणाली में निहित है। यहाँ 5 पैटर्न हैं जो आपको एक वरिष्ठ इंजीनियर के रूप में अलग करेंगे।
1. Generic Constraints
Generics शक्तिशाली हैं, लेकिन कभी-कभी आपको सीमित करने की आवश्यकता होती है कि क्या पारित किया जा सकता है। extends यहाँ आपका मित्र है।
interface HasId { id: string; } function getById<T extends HasId>(list: T[], id: string): T | undefined { return list.find((item) => item.id === id); }
यह सुनिश्चित करके कि T HasId का विस्तार करता है, हम गारंटी देते हैं कि फ़ंक्शन के अंदर .id तक पहुंचना सुरक्षित है।
2. Conditional Types
Conditional types आपको गैर-समान प्रकार की मैपिंग बनाने की अनुमति देते हैं। सिंटैक्स JavaScript में टर्नरी ऑपरेटर के समान है।
type IsString<T> = T extends string ? true : false; type A = IsString<string>; // true type B = IsString<number>; // false
एक व्यावहारिक उपयोग का मामला एक संघ से प्रकारों को फ़िल्टर करना है:
type Diff<T, U> = T extends U ? never : T; type NonNullable<T> = Diff<T, null | undefined>;
3. Mapped Types
Mapped types आपको गुणों को बदलकर पुराने प्रकारों के आधार पर नए प्रकार बनाने की अनुमति देते हैं।
type ReadOnly<T> = { readonly [P in keyof T]: T[P]; }; interface User { name: string; age: number; } type ReadOnlyUser = ReadOnly<User>;
आप संशोधक जोड़ या हटा भी सकते हैं:
type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
4. Template Literal Types
TypeScript 4.1 में पेश किया गया, ये आपको सीधे स्ट्रिंग प्रकारों में हेरफेर करने की अनुमति देते हैं।
type World = 'world'; type Greeting = `hello ${World}`; // "hello world" type Color = 'red' | 'blue'; type Quantity = 'light' | 'dark'; type Palette = `${Quantity}-${Color}`; // "light-red" | "light-blue" | "dark-red" | "dark-blue"
यह उन स्ट्रिंग्स को टाइप करने के लिए अविश्वसनीय रूप से उपयोगी है जो एक विशिष्ट पैटर्न का पालन करते हैं, जैसे CSS कक्षाएं या ईवेंट नाम।
5. infer कीवर्ड
Conditional types के भीतर infer कीवर्ड आपको अन्य प्रकारों से प्रकार निकालने की अनुमति देता है।
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function check(): boolean { return true; } type CheckReturn = ReturnType<typeof check>; // boolean
यहाँ, हम TypeScript को एक फ़ंक्शन के रिटर्न प्रकार R को "अनुमान" लगाने और इसे वापस करने के लिए कह रहे हैं।
निष्कर्ष
इन पैटर्नों में महारत हासिल करने से आप पुस्तकालय और उपयोगिताओं को लिखने की अनुमति देते हैं जो मजबूत हैं और उत्कृष्ट डेवलपर अनुभव (DX) प्रदान करते हैं। उन्नत TypeScript का लक्ष्य जटिलता के लिए जटिलता नहीं है, बल्कि सुरक्षा और अभिव्यक्ति है।