वरिष्ठ इंजीनियरों के लिए 5 उन्नत TypeScript पैटर्न

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 का लक्ष्य जटिलता के लिए जटिलता नहीं है, बल्कि सुरक्षा और अभिव्यक्ति है।