टाइपस्क्रिप्ट में यूटिलिटी प्रकार

यह लेख टाइपस्क्रिप्ट में यूटिलिटी प्रकारों को समझाता है।

YouTube Video

टाइपस्क्रिप्ट में यूटिलिटी प्रकार

टाइपस्क्रिप्ट यूटिलिटी प्रकार मौजूदा प्रकारों के आधार पर नए प्रकार बनाने के लिए सुविधाजनक उपकरण हैं। यह अधिक लचीले प्रकार की परिभाषाओं की अनुमति देता है और कोड पुन: उपयोग क्षमता को बढ़ाता है। यहां, हम आमतौर पर उपयोग किए जाने वाले यूटिलिटी प्रकारों को विस्तार से समझाएंगे और उदाहरण कोड के साथ प्रत्येक का उपयोग कैसे करें इस पर चर्चा करेंगे।

Partial<T>

Partial<T> किसी वस्तु प्रकार की सभी गुणों को वैकल्पिक (अनिर्दिष्ट undefined को अनुमति देते हुए) बनाता है। यह तब उपयोगी है जब आप केवल मूल प्रकार में से कुछ गुणों का उपयोग करना चाहते हैं।

 1interface User {
 2  id: number;
 3  name: string;
 4  age: number;
 5}
 6
 7function updateUser(user: Partial<User>) {
 8  console.log(user);
 9}
10
11updateUser({ name: "Alice" }); // Updates only 'name'

व्याख्या:

उपरोक्त उदाहरण में, Partial<User> का उपयोग User प्रकार के सभी गुणों को वैकल्पिक बनाता है। इसलिए, updateUser फ़ंक्शन में, आप केवल गुणों का एक उपसमुच्चय पास कर सकते हैं।

Required<T>

Required<T> सभी गुणों को, जिनमें वैकल्पिक गुण भी शामिल हैं, आवश्यक बनाता है। यह उस समय उपयोग किया जाता है जब आप वैकल्पिक गुणों को आवश्यक गुणों में बदलना चाहते हैं।

 1interface User {
 2  id: number;
 3  name?: string;
 4  age?: number;
 5}
 6
 7function createUser(user: Required<User>) {
 8  console.log(user);
 9}
10
11// createUser({ id: 1 }); // Error: 'name' and 'age' are required
12createUser({ id: 1, name: "Alice", age: 25 });

व्याख्या:

Required<User> का उपयोग करके, name और age जैसे गुणों को आवश्यक के रूप में समझा जाता है।

Readonly<T>

Readonly<T> किसी वस्तु के सभी गुणों को केवल पढ़ने योग्य बनाता है। यह वस्तु के मानों को बदले जाने से रोकता है।

 1interface User {
 2  id: number;
 3  name: string;
 4}
 5
 6const user: Readonly<User> = {
 7  id: 1,
 8  name: "Alice"
 9};
10
11// user.id = 2; // Error: 'id' is read-only
12console.log(user);

व्याख्या:

Readonly<T> का उपयोग करके, आप किसी वस्तु के गुणों को बदला जाने से बचा सकते हैं। यह तब प्रभावी होता है जब आप विकास के दौरान डेटा को गलती से बदले जाने से रोकना चाहते हैं।

Record<K, T>

Record<K, T> निर्दिष्ट कुंजी और मान प्रकारों के साथ एक मैप प्रकार बनाता है। K कुंजियों के लिए प्रकार है (जैसे string या number), और T मानों के लिए प्रकार है।

 1type Roles = "admin" | "user" | "guest";
 2interface Permissions {
 3  read: boolean;
 4  write: boolean;
 5}
 6
 7const rolePermissions: Record<Roles, Permissions> = {
 8  admin: { read: true, write: true },
 9  user: { read: true, write: false },
10  guest: { read: false, write: false },
11};
12
13console.log(rolePermissions);

व्याख्या:

Record<K, T> उपयोगी है जब आप कुंजी-मूल्य युग्म परिभाषित करना चाहते हैं। उपरोक्त उदाहरण में, अनुमतियां उपयोगकर्ता भूमिकाओं के आधार पर परिभाषित की गई हैं।

Pick<T, K>

Pick<T, K> किसी वस्तु प्रकार से केवल निर्दिष्ट गुणों को निकालता है। आप केवल आवश्यक गुणों को निकाल कर एक नया प्रकार बना सकते हैं।

 1interface User {
 2  id: number;
 3  name: string;
 4  age: number;
 5}
 6
 7type UserSummary = Pick<User, "id" | "name">;
 8
 9const summary: UserSummary = {
10  id: 1,
11  name: "Alice"
12};
13
14console.log(summary);

व्याख्या:

Pick<T, K> का उपयोग करके, आप किसी वस्तु प्रकार से विशिष्ट गुणों को निकाल सकते हैं और उन्हें एक नए प्रकार के रूप में समझ सकते हैं। उदाहरण के लिए, उपरोक्त उदाहरण में केवल id और name निकाले गए हैं।

Omit<T, K>

Omit<T, K> ऑब्जेक्ट टाइप से निर्दिष्ट गुणों को हटाता है। यह Pick का विपरीत संचालन है।

 1interface User {
 2  id: number;
 3  name: string;
 4  age: number;
 5  email: string;
 6}
 7
 8type UserWithoutEmail = Omit<User, "email">;
 9
10const userWithoutEmail: UserWithoutEmail = {
11  id: 1,
12  name: "Alice",
13  age: 25
14};
15
16console.log(userWithoutEmail);

व्याख्या:

Omit<T, K> का उपयोग करके आप निर्दिष्ट गुणों को छोड़कर एक नया प्रकार बना सकते हैं। ऊपर दिए गए उदाहरण में, email प्रॉपर्टी को बाहर कर दिया गया है।

Exclude<T, U>

Exclude<T, U> संघ प्रकार T से प्रकार U को हटाकर एक नया प्रकार बनाता है। इसका उपयोग तब किया जाता है जब आप किसी विशिष्ट प्रकार को हटाना चाहते हैं।

1type Status = "active" | "inactive" | "pending";
2type ExcludedStatus = Exclude<Status, "pending">;
3
4const status: ExcludedStatus = "active"; // "pending" is excluded, so it cannot be chosen
5console.log(status);

व्याख्या:

Exclude<T, U> का उपयोग करके आप संघ प्रकार के भीतर अनावश्यक प्रकारों को हटा सकते हैं। ऊपर दिए गए उदाहरण में, चूंकि "pending" को बाहर रखा गया है, केवल "active" या "inactive" का चयन किया जा सकता है।

Extract<T, U>

Extract<T, U> संघ प्रकार T के भीतर प्रकार U से मेल खाने वाले भागों को निकालता है। यह तब उपयोगी होता है जब आप केवल एक विशिष्ट प्रकार को निकालना चाहते हैं।

1type Status = "active" | "inactive" | "pending";
2type ActiveStatus = Extract<Status, "active" | "pending">;
3
4const status: ActiveStatus = "active"; // "inactive" cannot be chosen
5console.log(status);

व्याख्या:

Extract<T, U> Exclude का विपरीत संचालन करता है। ऊपर दिए गए उदाहरण में, केवल "active" और "pending" को ही चुना जा सकता है।

NonNullable<T>

NonNullable<T> ऐसा प्रकार बनाता है जिसमें null और undefined को बाहर रखा गया हो। यह तब सहायक होता है जब आप वैकल्पिक प्रकारों से इन मानों को हटाना चाहते हैं।

1type UserName = string | null | undefined;
2type ValidUserName = NonNullable<UserName>;
3
4const name: ValidUserName = "Alice"; // null and undefined cannot be chosen
5console.log(name);

व्याख्या:

NonNullable<T> उन प्रकारों से null और undefined को हटाता है जो उन्हें शामिल करते हैं। यह तब उपयोगी होता है जब आप यह सुनिश्चित करना चाहते हैं कि कोई मान निश्चित रूप से मौजूद है।

निष्कर्ष

TypeScript उपयोगिता प्रकार प्रकार परिभाषाओं को अधिक संक्षिप्त और लचीला बनाने के लिए शक्तिशाली उपकरण हैं। Partial, Required, Readonly, Record, आदि जैसे बुनियादी उपयोगिता प्रकारों को समझना और सही ढंग से उपयोग करना कोड पुन: उपयोग क्षमता और रखरखाव क्षमता को बढ़ा सकता है। इन प्रकारों में महारत हासिल करना अधिक मजबूत और सुरक्षित प्रकार परिभाषाओं की अनुमति देता है, जो कुशल विकास को सक्षम बनाता है।

TypeScript का keyof ऑपरेटर

TypeScript का keyof ऑपरेटर ऑब्जेक्ट प्रकार की सभी प्रॉपर्टी नेम्स प्राप्त करने के लिए उपयोग किया जाता है। इस ऑपरेटर का उपयोग करके, आप एक ऑब्जेक्ट प्रकार की कुंजियों को एक संघ प्रकार के रूप में प्राप्त कर सकते हैं। यह टाइप-सुरक्षित कोड लिखने के लिए अत्यधिक उपयोगी है।

मूल उपयोग

1interface Person {
2    name: string;
3    age: number;
4    email: string;
5}
6
7// Use keyof to get the property names of Person
8type PersonKeys = keyof Person; // "name" | "age" | "email"

उदाहरण उपयोग

1. इसे फ़ंक्शन तर्कों में उपयोग करना

   आप keyof का उपयोग करके एक फ़ंक्शन परिभाषित कर सकते हैं जिसमें प्रकार किसी वस्तु की विशिष्ट गुणों पर आधारित होते हैं।

1function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
2    return obj[key];
3}
4
5const person: Person = { name: "Alice", age: 30, email: "alice@example.com" };
6const name = getProperty(person, "name"); // type is string
7const age = getProperty(person, "age");   // type is number

2. प्रकार बाधाओं को बढ़ाना

   keyof का उपयोग करके, आप सुनिश्चित कर सकते हैं कि फ़ंक्शन को दी गई कुंजियां कंपाइल समय पर मान्य हैं।

1// Passing an invalid property name results in an error
2const invalid = getProperty(person, "invalidKey"); // Error

सारांश

• keyof ऑपरेटर का उपयोग किसी वस्तु प्रकार की सभी गुणों के नाम प्राप्त करने के लिए किया जाता है।
• आप गुणों के नाम को एक संघ प्रकार के रूप में प्राप्त कर सकते हैं, जो टाइप-सुरक्षित कोड प्राप्त करता है।
• इसे फ़ंक्शन तर्कों में उपयोग करके, आप फ़ंक्शन को केवल वैध गुण नाम स्वीकार करने तक सीमित कर सकते हैं।

इस प्रकार, keyof ऑपरेटर TypeScript में टाइप सुरक्षा को बढ़ाता है और आपको अधिक मजबूत कोड लिखने में मदद करता है।

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video