TypeScript प्रोग्रामिंग में सर्वोत्तम अभ्यास
यह लेख TypeScript प्रोग्रामिंग में सर्वोत्तम अभ्यासों को समझाता है।
यह मार्गदर्शिका TypeScript के प्रकारों का उपयोग करके बग्स को कम करने और अधिक पठनीय कोड लिखने के व्यावहारिक सर्वोत्तम अभ्यासों को समझाती है।
YouTube Video
TypeScript प्रोग्रामिंग में सर्वोत्तम अभ्यास
TypeScript का सबसे बड़ा लाभ 'प्रकारों द्वारा बग रोकना और कोड की मंशा स्पष्ट करना' है।
सर्वोत्तम अभ्यास केवल नियम नहीं हैं, बल्कि यह सुरक्षित, पठनीय और बनाए रखने योग्य कोड लिखने के सिद्धांतों का एक समूह हैं। नीचे, हम व्यावहारिक उदाहरणों के साथ सामान्यतः उपयोग किए जाने वाले TypeScript सर्वोत्तम अभ्यासों का परिचय कराते हैं।
any का उपयोग करने से बचें और हमेशा प्रकारों को अर्थपूर्ण परिभाषाएं दें
सबसे पहले, आइए 'any से बचने और सार्थक टाइप्स देने' के बिंदु पर ध्यान दें।
any पूरी तरह से प्रकार जांच को निष्क्रिय कर देता है, जिससे TypeScript का उपयोग करने का उद्देश्य ही समाप्त हो जाता है। सिर्फ चीजों को काम कराने के लिए any का उपयोग करने के बजाय, जितना संभव हो, उतना वर्णात्मक प्रकार प्रदान करना महत्वपूर्ण है।
1// Bad
2function parse(data: any) {
3 return data.value;
4}यह कोड किसी भी मान को स्वीकार कर सकता है, जिससे रनटाइम त्रुटियों को रोका नहीं जा सकता।
1// Good
2type ParsedData = {
3 value: string;
4};
5
6function parse(data: ParsedData): string {
7 return data.value;
8}प्रकारों को परिभाषित करके, आप इनपुट और आउटपुट की मंशा स्पष्ट करते हैं और सुरक्षा बढ़ाते हैं।
हमेशा type या interface का उपयोग करके ऑब्जेक्ट संरचनाओं को स्पष्ट रूप से परिभाषित करें।
अब, आइए 'हमेशा ऑब्जेक्ट स्ट्रक्चर को type या interface का उपयोग करके स्पष्ट रूप से परिभाषित करने' के बिंदु पर ध्यान दें।
यदि आप ऑब्जेक्ट्स का अस्थायी रूप से उपयोग करते हैं, तो उनकी संरचना अस्पष्ट हो सकती है। पुन: प्रयोग और रखरखाव के लिए हमेशा प्रकारों को अलग करें।
1// Bad
2function createUser(user: { name: string; age: number }) {
3 console.log(user.name);
4}यहां तक कि कोड के छोटे हिस्सों में भी, प्रकारों को अलग करने की आदत बनाना महत्वपूर्ण है।
1// Good
2type User = {
3 name: string;
4 age: number;
5};
6
7function createUser(user: User): void {
8 console.log(user.name);
9}प्रकारों का नामकरण करके, पूरे कोडबेस को समझना बहुत आसान हो जाता है।
सभी संभावित अवस्थाओं को सटीक रूप से दर्शाने के लिए यूनियन प्रकारों का उपयोग करें।
यदि आप कंडीशन के लिए कच्चे string या number प्रकारों का उपयोग करते हैं, तो अप्रत्याशित मान अंदर आ सकते हैं। यूनियन प्रकारों का उपयोग करके, आप केवल अनुमत अवस्थाओं का प्रकार स्तर पर प्रतिनिधित्व कर सकते हैं।
1// Bad
2function setStatus(status: string) {
3 console.log(status);
4}इस कोड में, बेकार स्ट्रिंग्स या गलत मानों का संकलन समय पर पता नहीं लगाया जा सकता।
1// Good
2type Status = "idle" | "loading" | "success" | "error";
3
4function setStatus(status: Status): void {
5 console.log(status);
6}यूनियन प्रकारों का उपयोग करके, आप संकलन समय पर 'असंभव अवस्थाओं' को विश्वसनीय रूप से समाप्त कर सकते हैं। इसके परिणामस्वरूप, सशर्त शाखाओं की सुरक्षा और कोड की विश्वसनीयता में सुधार होगा।
null और undefined को स्पष्ट रूप से संभालें।
अब, आइए 'null और undefined को स्पष्ट रूप से संभालने' के बिंदु पर ध्यान दें।
TypeScript में, किसी मान की संभावित अनुपस्थिति को प्रकार में व्यक्त करना महत्वपूर्ण है। यदि आप चीजों को अस्पष्ट रखते हैं, तो वे रनटाइम त्रुटियों का कारण बन सकती हैं।
1type User = {
2 name: string;
3 email?: string;
4};email मौजूद नहीं हो सकता, इसलिए आपको इसे उसी धारणा के साथ संभालना चाहिए।
1function printEmail(user: User): void {
2 if (user.email) {
3 console.log(user.email);
4 }
5}किसी भी वैकल्पिक मान का उपयोग करने से पहले उसे हमेशा जांचें।
टाइप एसेर्शन (as) का उपयोग केवल अंतिम उपाय के रूप में करें।
अब, आइए 'type assertions का अत्यधिक उपयोग न करने' के बिंदु पर ध्यान दें।
टाइप असर्शन अस्थायी रूप से TypeScript के प्रकार जाँच को दरकिनार करते हैं और घोषणा करते हैं, 'मुझे पता है कि यह मान इस प्रकार का है।'। इनका अत्यधिक उपयोग टाइप सुरक्षा को कमज़ोर कर देता है।
1// Bad
2const value = input as string;इस कोड में, यदि वास्तविक मान स्ट्रिंग नहीं भी है, तब भी कोई त्रुटि नहीं आती है, जिससे रनटाइम त्रुटियाँ हो सकती हैं। जैसा कि निम्न कोड में दिखाया गया है, पहले सुरक्षित जाँच के लिए टाइप गार्ड्स का उपयोग चुनें।
1// Good
2function isString(value: unknown): value is string {
3 return typeof value === "string";
4}
5
6if (isString(input)) {
7 console.log(input.toUpperCase());
8}टाइप गार्ड्स एक तंत्र हैं जो वास्तविक मान की जाँच करते समय प्रकार को सुरक्षित रूप से निर्धारित करते हैं। टाइप असर्शन की तुलना में टाइप गार्ड्स को प्राथमिकता देकर, आप रनटाइम त्रुटियों को अधिक आसानी से रोक सकते हैं।
रिटर्न टाइप्स के लिए प्रकार अनुमान पर ज्यादा निर्भर न रहें।
अब, आइए 'return types के लिए inference पर ज्यादा निर्भर न रहने' के बिंदु पर ध्यान दें।
TypeScript का प्रकार अनुमान शक्तिशाली है, लेकिन सार्वजनिक फ़ंक्शनों के रिटर्न टाइप को स्पष्ट रूप से एनोटेट करना अधिक सुरक्षित है। यह भविष्य में बदलावों के संभावित प्रभाव को कम करता है।
1// Bad
2function sum(a: number, b: number) {
3 return a + b;
4}यहां तक कि छोटे फ़ंक्शनों में भी अपनी मंशा स्पष्ट रूप से बताएं।
1// Good
2function sum(a: number, b: number): number {
3 return a + b;
4}रिटर्न टाइप्स लिखने से आपके API की स्थिरता बढ़ती है।
unknown का उपयोग करके इनपुट को सुरक्षित रूप से संभालें।
अब, आइए 'unknown का उपयोग करके बाहरी इनपुट को सुरक्षित रूप से स्वीकार करने' के बिंदु पर ध्यान दें।
बाहरी इनपुट जैसे कि APIs, JSON, या उपयोगकर्ता इनपुट के लिए, any की जगह unknown का उपयोग करें। ऐसा करने से आप यह सुनिश्चित करते हैं कि सभी मान जांचे गए हैं, जिससे प्रकार सुरक्षा बनी रहती है।
1// Bad
2function handleResponse(data: any) {
3 console.log(data.id);
4}यहां बताया गया है कि unknown के साथ प्रकारों को कैसे मान्य करें।
1// Good
2function handleResponse(data: unknown): void {
3 if (
4 typeof data === "object" &&
5 data !== null &&
6 "id" in data
7 ) {
8 console.log((data as { id: number }).id);
9 }
10}unknown को जैसी है वैसी उपयोग नहीं किया जा सकता; यह एक ऐसा प्रकार है जिसमें सत्यापन आवश्यक है। यह विशेष रूप से बाहरी इनपुट को संभालते समय प्रभावी होता है।
छोटे प्रकारों को जोड़कर स्पष्टता बढ़ाएं।
अब, आइए 'छोटे-छोटे टाइप्स को जोड़कर अभिव्यक्तता बढ़ाने' के बिंदु पर ध्यान दें।
एक साथ बड़े प्रकार परिभाषित करने से पठनीयता और रखरखाव कम हो जाता है। अपने प्रकारों को अर्थपूर्ण इकाइयों में विभाजित करें और आवश्यकता अनुसार उन्हें संयोजित करें।
1type Id = number;
2
3type UserProfile = {
4 id: Id;
5 name: string;
6};
7
8type UserWithStatus = UserProfile & {
9 status: "active" | "inactive";
10};प्रकारों को घटकों के रूप में मानने से आपके डिज़ाइन को व्यवस्थित करने में मदद मिलती है।
type और interface
interface के लाभ
type और interface दोनों प्रकारों को परिभाषित कर सकते हैं, लेकिन उनके उपयोग के इरादे और विशेषताएँ भिन्न हैं। उन्हें उचित भूमिकाओं के लिए उपयोग करके आपके प्रकार परिभाषाओं की मंशा और स्पष्ट हो जाती है।
1// Bad
2type User = {
3 id: number;
4 name: string;
5};
6
7type AdminUser = {
8 id: number;
9 name: string;
10 role: "admin";
11};यदि आप सामान्य हिस्सों को इस तरह डुप्लिकेट करते हैं, तो आपका कोड बदलावों के प्रति संवेदनशील हो जाता है।
1// Good
2interface User {
3 id: number;
4 name: string;
5}
6
7interface AdminUser extends User {
8 role: "admin";
9}interface उन डिजाइनों के लिए आदर्श है जिसमें विस्तार (extends) शामिल है और वस्तुओं के 'आकार' को व्यक्त करने के लिए सर्वोत्तम है।
type के लाभ
दूसरी ओर, type अधिक अभिव्यक्तिपूर्ण है और यूनियन व इंटरसेक्शन प्रकारों की हैंडलिंग के लिए उपयुक्त है।
1// Good
2type Status = "idle" | "loading" | "success" | "error";
3
4type ApiResponse<T> =
5 | { status: "success"; data: T }
6 | { status: "error"; message: string };type अवस्थाओं, विकल्पों और संयोजनों को व्यक्त करने के लिए अनुकूल है।
type और interface के बीच चयन के लिए दिशानिर्देश
साधारण नियम के रूप में, ऑब्जेक्ट संरचनाओं और अनुबंधों के लिए interface का उपयोग करें, और यूनियन, इंटरसेक्शन, या प्रकार संचालन की स्पष्टता के लिए type का उपयोग करें।
दोनों लगभग समान काम करते हैं, लेकिन प्रकार की उपस्थिति के कारण को व्यक्त करने के लिए चुनाव करना जरूरी है।
अपने प्रकारों को प्रलेखन के रूप में मानें।
अंत में, आइए 'टाइप्स को डाक्यूमेंटेशन के रूप में लिखने' के बिंदु पर ध्यान दें।
अच्छी प्रकार परिभाषाएं टिप्पणियों की तुलना में कहीं अधिक जानकारी प्रदान करती हैं। यह महत्वपूर्ण है कि ऐसी स्थिति का लक्ष्य रखा जाए जहाँ 'सिर्फ टाइप्स देखकर ही स्पेसिफिकेशन समझा जा सके।'।
1type ApiError = {
2 code: number;
3 message: string;
4 retryable: boolean;
5};इस प्रकार, TypeScript की एक बड़ी ताकत यह है कि टाइप डेफिनिशन एक तरह के स्पेसिफिकेशन डॉक्युमेंट के रूप में काम कर सकते हैं।
सारांश
TypeScript के सर्वोत्तम अभ्यास अत्यधिक कठोर होने के बारे में नहीं हैं। मूल तत्व है प्रकारों के माध्यम से मंशा स्पष्ट करना और परिवर्तन के प्रति मजबूत कोड लिखना।
दैनिक विकास में छोटे-छोटे नियमों को अपनाकर, आप 'आसान समीक्षा', 'कम बग' और 'अपने भविष्य के लिए और दूसरों के लिए बेहतर समझ' जैसे दीर्घकालिक परिणाम प्राप्त कर सकते हैं।
सबसे पहले, 'मैं इसे प्रकारों के साथ कैसे व्यक्त कर सकता हूँ?' इस तरह सोचकर आप उच्च-गुणवत्ता वाला, TypeScript-शैली का कोड लिखेंगे।
आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।