1~
2TypeScript बड़े पैमाने पर वेब विकास के लिए उद्योग मानक बन गया है। जबकि अधिकांश डेवलपर्स इंटरफेस और प्रकारों की मूल बातें जानते हैं, वास्तविक शक्ति इसके उन्नत प्रकार प्रणाली में निहित है। यहाँ 5 पैटर्न हैं जो आपको एक वरिष्ठ इंजीनियर के रूप में अलग करेंगे।
3~
4## 1. Generic Constraints
5~
6Generics शक्तिशाली हैं, लेकिन कभी-कभी आपको सीमित करने की आवश्यकता होती है कि क्या पारित किया जा सकता है। `extends` यहाँ आपका मित्र है।
7~
8```typescript
9interface HasId {
10  id: string;
11}
12~
13function getById<T extends HasId>(list: T[], id: string): T | undefined {
14  return list.find((item) => item.id === id);
15}
16```
17~
18यह सुनिश्चित करके कि `T` `HasId` का विस्तार करता है, हम गारंटी देते हैं कि फ़ंक्शन के अंदर `.id` तक पहुंचना सुरक्षित है।
19~
20## 2. Conditional Types
21~
22Conditional types आपको गैर-समान प्रकार की मैपिंग बनाने की अनुमति देते हैं। सिंटैक्स JavaScript में टर्नरी ऑपरेटर के समान है।
23~
24```typescript
25type IsString<T> = T extends string ? true : false;
26~
27type A = IsString<string>; // true
28type B = IsString<number>; // false
29```
30~
31एक व्यावहारिक उपयोग का मामला एक संघ से प्रकारों को फ़िल्टर करना है:
32~
33```typescript
34type Diff<T, U> = T extends U ? never : T;
35type NonNullable<T> = Diff<T, null | undefined>;
36```
37~
38## 3. Mapped Types
39~
40Mapped types आपको गुणों को बदलकर पुराने प्रकारों के आधार पर नए प्रकार बनाने की अनुमति देते हैं।
41~
42```typescript
43type ReadOnly<T> = {
44  readonly [P in keyof T]: T[P];
45};
46~
47interface User {
48  name: string;
49  age: number;
50}
51~
52type ReadOnlyUser = ReadOnly<User>;
53```
54~
55आप संशोधक जोड़ या हटा भी सकते हैं:
56~
57```typescript
58type Mutable<T> = {
59  -readonly [P in keyof T]: T[P];
60};
61```
62~
63## 4. Template Literal Types
64~
65TypeScript 4.1 में पेश किया गया, ये आपको सीधे स्ट्रिंग प्रकारों में हेरफेर करने की अनुमति देते हैं।
66~
67```typescript
68type World = 'world';
69type Greeting = `hello ${World}`; // "hello world"
70~
71type Color = 'red' | 'blue';
72type Quantity = 'light' | 'dark';
73~
74type Palette = `${Quantity}-${Color}`;
75// "light-red" | "light-blue" | "dark-red" | "dark-blue"
76```
77~
78यह उन स्ट्रिंग्स को टाइप करने के लिए अविश्वसनीय रूप से उपयोगी है जो एक विशिष्ट पैटर्न का पालन करते हैं, जैसे CSS कक्षाएं या ईवेंट नाम।
79~
80## 5. `infer` कीवर्ड
81~
82Conditional types के भीतर `infer` कीवर्ड आपको अन्य प्रकारों से प्रकार निकालने की अनुमति देता है।
83~
84```typescript
85type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;
86~
87function check(): boolean {
88  return true;
89}
90~
91type CheckReturn = ReturnType<typeof check>; // boolean
92```
93~
94यहाँ, हम TypeScript को एक फ़ंक्शन के रिटर्न प्रकार `R` को "अनुमान" लगाने और इसे वापस करने के लिए कह रहे हैं।
95~
96## निष्कर्ष
97~
98इन पैटर्नों में महारत हासिल करने से आप पुस्तकालय और उपयोगिताओं को लिखने की अनुमति देते हैं जो मजबूत हैं और उत्कृष्ट डेवलपर अनुभव (DX) प्रदान करते हैं। उन्नत TypeScript का लक्ष्य जटिलता के लिए जटिलता नहीं है, बल्कि सुरक्षा और अभिव्यक्ति है।
99~