TypeScript: Enum Validation सह रिटर्न

Lina Fontaine

सोमवार, १८ नोव्हेंबर, २०२४ रोजी ५:१७:१५ म.उ.

जटिल TypeScript API मध्ये प्रकार सुरक्षितता सुनिश्चित करणे

सोबत काम करताना टाइपस्क्रिप्ट क्लिष्ट ऍप्लिकेशन्समध्ये, प्रत्येक फंक्शन किंवा पद्धत कठोर प्रकारच्या संरचनेशी सुसंगत असल्याची खात्री करणे महत्वाचे आहे. पण जेव्हा चुकून रिटर्न ऑब्जेक्टमध्ये अतिरिक्त गुणधर्म जोडले जातात तेव्हा काय होते? बऱ्याचदा, TypeScript समस्येकडे दुर्लक्ष करते, कोडला चेतावणीशिवाय पास करण्याची परवानगी देते. यामुळे लपलेले बग येऊ शकतात जे नंतर शोधणे कठीण होऊ शकते.

उदाहरणार्थ, तुम्ही एपीआय प्रतिसाद हँडलर डिझाइन करत आहात अशी परिस्थिती घ्या. हँडलरच्या रिटर्न प्रकारात फक्त विशिष्ट फील्ड समाविष्ट करणे अपेक्षित असल्यास-म्हणजे, "चाचणी" आणि "मर्यादा"—परंतु अतिरिक्त, अनपेक्षित गुणधर्म डोकावले तर ते कार्यक्षमता बंद करू शकते. कठोर प्रकारच्या मर्यादांची अंमलबजावणी केल्याने तुम्हाला अनपेक्षित परिणाम किंवा रनटाइम त्रुटींपासून वाचवता येईल, विशेषत: मोठे किंवा सामायिक केलेले कोडबेस व्यवस्थापित करताना. 😊

या लेखात, आम्ही वापरून API सेटअपचे उदाहरण पाहू टाइपस्क्रिप्ट ज्यामध्ये दोन भिन्न स्कोप समाविष्ट आहेत: "सूची" आणि "जेनेरिक." प्रत्येक स्कोपची स्वतःची अपेक्षित रचना असते, परंतु प्रतिसादामध्ये कोणतेही अतिरिक्त फील्ड दिसणार नाहीत याची खात्री करणे हे आव्हान आहे. TypeScript चे शक्तिशाली टाइप-चेकिंग आणि enums वापरून, आम्ही स्वच्छ, अंदाज लावता येण्याजोगा कोड सुनिश्चित करण्यासाठी हे नियम लागू करू शकतो.

आम्ही TypeScript मध्ये मजबूत प्रकार कसे तयार करू शकतो हे पाहण्यासाठी अनुसरण करा जे केवळ आमच्या वस्तूंचे आकार परिभाषित करत नाहीत तर कोणत्याही अपघाती जोडण्या टाळण्यासाठी प्रतिबंध देखील लागू करतात - स्वच्छ आणि अधिक विश्वासार्ह कोडबेससाठी एक सुरक्षा प्रदान करते. 🚀

आज्ञा	वापराचे उदाहरण
ScopeType	केवळ LIST आणि GENERIC ला वैध नोंदी म्हणून अनुमती देऊन, व्याप्तीसाठी विशिष्ट, मर्यादित मूल्ये परिभाषित करण्यासाठी वापरलेला enum. हे विशिष्ट मूल्यांचे कठोर पालन सुनिश्चित करते, अनपेक्षित इनपुटमधून संभाव्य त्रुटी कमी करते.
type List<T>	एक TypeScript युटिलिटी प्रकार जेनेरिक प्रकार T वाढवण्यासाठी मर्यादा गुणधर्म जोडून, मर्यादा फील्ड समाविष्ट करण्यासाठी LIST स्कोप्ड प्रतिसादांमध्ये रचना लागू करून वापरला जातो.
EnforceExactKeys<T, U>	U मधील गुणधर्म T मधील गुणधर्मांशी तंतोतंत जुळत असल्याची खात्री करून घेणारा सानुकूल मदतनीस प्रकार, कोणतेही जादा किंवा गहाळ फील्ड प्रतिबंधित करतो आणि रिटर्न स्ट्रक्चरमध्ये कठोर टायपिंग लागू करतो.
validateApiProps	एक प्रमाणीकरण कार्य जे स्कोप प्रकारावर आधारित हाताळणी वेगळे करते, अचूक रिटर्न संरचना लागू करताना LIST किंवा GENERIC scoped प्रकारांसाठी लक्ष्यित हाताळणी प्रदान करते.
StrictShape<Expected>	एक मॅप केलेला प्रकार जो अपेक्षित मधील प्रत्येक की तंतोतंत जुळतो असे लागू करून कठोर ऑब्जेक्ट आकार परिभाषित करतो, अतिरिक्त गुणधर्मांना परवानगी न देता, जे अचूक रिटर्न संरचना सुनिश्चित करते.
describe() & test()	युनिट चाचण्यांची रचना आणि आयोजन करण्यासाठी जेस्टची कार्ये वापरली जातात. वर्णन() गट चाचण्या तार्किकरित्या करा, तर test() API प्रकार अनुरूपता आणि त्रुटी हाताळणी प्रमाणित करण्यासाठी विशिष्ट चाचणी प्रकरणे परिभाषित करते.
expect(...).toThrowError()	अवैध प्रकार किंवा अनपेक्षित गुणधर्म प्रदान केल्यावर फंक्शनने एरर टाकली की नाही याची पडताळणी करणारी जेस्ट ॲसर्टेशन पद्धत, प्रकार अंमलबजावणीमध्ये योग्य त्रुटी हाताळणे सुनिश्चित करते.
props: (storeState: string) => List<T>	प्रॉप्स फील्डमधील फंक्शन स्वाक्षरी, रिटर्न व्हॅल्यू सूची प्रकाराशी काटेकोरपणे अनुरूप असणे आवश्यक आहे हे निर्दिष्ट करते. हे लागू करते की स्कोप प्रकारावर आधारित योग्य रचना परत केली जाते.
<T extends unknown>	apiProps ला विशिष्ट निर्बंधांशिवाय कोणताही प्रकार T स्वीकारण्याची अनुमती देणारी सामान्य मर्यादा. हे कार्य व्याप्ती आणि रिटर्न स्ट्रक्चरवर नियंत्रण ठेवत असताना विविध प्रकारांना अनुकूल बनवते.

API प्रतिसादांसाठी TypeScript प्रकार अंमलबजावणीमध्ये खोलवर जा

TypeScript मध्ये, API प्रतिसादांसाठी काटेकोर प्रकारच्या तपासण्या लागू केल्याने त्रुटी लवकर पकडण्यात मदत होऊ शकते, विशेषत: जटिल प्रकार आणि enums सह काम करताना. वरील उदाहरण स्क्रिप्ट दोन विशिष्ट प्रकारचे API प्रतिसाद वापरून व्यवस्थापित करण्यासाठी डिझाइन केले आहेत TypeScript enums कठोर संरचना परिभाषित करण्यासाठी. एकतर "सूची" किंवा "जेनेरिक" प्रकारांमध्ये प्रतिसादांचे वर्गीकरण करून व्याप्ती प्रकार enum, आम्ही एक फ्रेमवर्क तयार करतो जिथे प्रत्येक स्कोपने अचूक रचना पाळली पाहिजे. API प्रतिसादांसारखी कार्ये परिभाषित करताना हे विशेषतः उपयुक्त आहे जेथे प्रत्येक प्रकारच्या प्रतिसादासाठी अद्वितीय फील्डची आवश्यकता असते—जसे की सूची प्रकारातील मर्यादा फील्ड जी जेनेरिक प्रकारात आवश्यक नसते. व्यवहारात, हे कोणत्याही अतिरिक्त गुणधर्माची खात्री देते, जसे की प्रतिसादातील अनपेक्षित “abc”, TypeScript द्वारे संकलित वेळी पकडले जातात, रनटाइम समस्यांना प्रतिबंधित करते आणि आमच्या ऍप्लिकेशन्समध्ये डेटा प्रवाह स्वच्छ ठेवतात.

हे साध्य करण्यासाठी, आम्ही दोन इंटरफेस परिभाषित केले, GetApiPropsGeneric आणि GetApiPropsList, जे प्रत्येक स्कोपच्या प्रतिसादासाठी रचना निर्दिष्ट करते. द प्रॉप्स या इंटरफेसमधील फंक्शन एकतर ए जेनेरिक प्रकार किंवा अ यादी प्रकार, व्याप्तीवर अवलंबून. जेनेरिक प्रकार लवचिक आहे, कोणत्याही संरचनेला परवानगी देतो, परंतु सूची प्रकार कठोर जोडतो मर्यादा फील्ड, LIST प्रतिसादांमध्ये ही मालमत्ता असल्याचे सुनिश्चित करणे. येथे खरी शक्ती हेल्पर प्रकारांद्वारे प्रदान केलेल्या अंमलबजावणीमध्ये आहे EnforceExactKeys, जे आम्हाला हे निर्दिष्ट करण्यास अनुमती देते की आमच्या रिटर्न ऑब्जेक्टमधील गुणधर्म अपेक्षित संरचनेशी तंतोतंत जुळले पाहिजेत - अतिरिक्त गुणधर्मांना परवानगी नाही. अनेक विकासकांसोबत मोठ्या प्रकल्पांचे व्यवस्थापन करताना हा दृष्टिकोन आवश्यक आहे जेथे अशा प्रकारच्या तपासण्या मूक त्रुटी टाळू शकतात. 👨💻

उपयुक्तता प्रकार EnforceExactKeys या सेटअप मध्ये महत्वाचे आहे. हे अपेक्षित प्रतिसाद रचनेतील प्रत्येक कीची तुलना करून ते प्रत्यक्ष प्रतिसाद प्रकाराशी तंतोतंत जुळत असल्याची खात्री करण्यासाठी कार्य करते. "abc" सारख्या कोणत्याही अतिरिक्त की आढळल्यास, TypeScript कंपाइल-टाइम एरर टाकेल. या पातळीच्या कडक तपासणीमुळे अशा समस्या टाळता येऊ शकतात ज्या अन्यथा केवळ उत्पादनात पकडल्या जातील. वरील स्क्रिप्ट मध्ये, वापर validateApiProps प्रमाणीकरणाचा दुय्यम स्तर जोडून केवळ निर्दिष्ट गुणधर्म स्वीकारले जातील याची खात्री करते. द validateApiProps फंक्शन प्रदान केलेल्या स्कोपच्या आधारावर विविध रिटर्न प्रकार निवडून कार्य करते, त्यामुळे संरचना लागू करताना ते जुळवून घेण्यासारखे आहे. हे ड्युअल-लेयर प्रकार अंमलबजावणी, EnforceExactKeys आणि validateApiProps या दोन्हींद्वारे, आमच्या TypeScript कोडबेसची मजबूतता वाढवते.

आमचे समाधान विश्वसनीय राहील याची खात्री करण्यासाठी, प्रत्येक कॉन्फिगरेशन सत्यापित करण्यासाठी युनिट चाचण्या जोडल्या गेल्या. जेस्ट वापरणे, द वर्णन करा आणि चाचणी फंक्शन्स तार्किक चाचणी गट आणि वैयक्तिक चाचणी प्रकरणे तयार करतात. द अपेक्षा(...).toThrowError() फंक्शन तपासते की अवैध गुणधर्म, जसे की लिस्ट स्कोप मधील “abc”, एरर ट्रिगर करते, आमची संरचना प्रमाणीकरण कार्य करते याची पुष्टी करते. उदाहरणार्थ, जर एखादी चुकीची मालमत्ता प्रॉप्समध्ये डोकावते, तर जेस्टच्या चाचण्या याला अयशस्वी चाचणी म्हणून हायलाइट करतील, विकासकांना समस्येचे त्वरित निराकरण करण्यात मदत करेल. प्रत्येक कॉन्फिगरेशनची काटेकोरपणे चाचणी करून, आम्ही विश्वास ठेवू शकतो की आमचे TypeScript सेटअप प्रत्येक प्रतिसाद प्रकार योग्यरित्या हाताळते आणि कोणत्याही विसंगतीसाठी योग्य त्रुटी टाकते—आमचा कोड अधिक सुरक्षित, अंदाज करण्यायोग्य आणि मजबूत बनवते. 🚀

API रिटर्न प्रकारांसाठी TypeScript मध्ये प्रकार मर्यादा लागू करणे

कंडिशनल प्रकार आणि कस्टम युटिलिटी प्रकार वापरून बॅक-एंड टाइपस्क्रिप्ट सोल्यूशन

// Define an enum to control scope types
enum ScopeType { LIST = "LIST", GENERIC = "GENERIC" }

// Define the types expected for each scope
type Generic<T> = T;
type List<T> = T & { limit: number; };

// Define interfaces with specific return shapes for each scope
interface GetApiPropsGeneric<T> {
  props: (storeState: string) => Generic<T>;
  api: (args: Generic<T>) => void;
  type: string;
  scope: ScopeType.GENERIC;
}

interface GetApiPropsList<T> {
  props: (storeState: string) => List<T>;
  api: (args: List<T>) => void;
  type: string;
  scope: ScopeType.LIST;
}

// Helper type to enforce strict property keys in props function
type EnforceExactKeys<T, U> = U & { [K in keyof U]: K extends keyof T ? U[K] : never };

// Main API function with type check for enforced keys
const apiProps = <T extends unknown>(a: GetApiPropsList<T> | GetApiPropsGeneric<T>) => {
  console.log("API call initiated");
}

// Valid usage with enforced property types
type NewT = { test: string };
apiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "1444", limit: 12 }),
  api: () => {},
  type: "example",
});

// Invalid usage, will produce a TypeScript error for invalid key
apiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "1444", limit: 12, abc: "error" }), // Extra key 'abc'
  api: () => {},
  type: "example",
});

पर्यायी उपाय: कठोर की अंमलबजावणीसाठी TypeScript मॅप केलेले प्रकार वापरणे

बॅक-एंड टाइपस्क्रिप्ट सोल्यूशन त्रुटी तपासण्यासाठी मॅप केलेले प्रकार लागू करते

१

API कार्य प्रमाणीकरणासाठी युनिट चाचण्या

रिटर्न प्रकार आणि संरचना अनुपालन लागू करण्यासाठी टाइपस्क्रिप्ट जेस्ट चाचण्या

import { validateApiProps } from './path_to_script';
describe('validateApiProps', () => {
  test('allows correct shape for LIST scope', () => {
    const validProps = {
      scope: ScopeType.LIST,
      props: (_) => ({ test: "value", limit: 10 }),
      api: () => {},
      type: "correct",
    };
    expect(() => validateApiProps(validProps)).not.toThrow();
  });

  test('throws error on invalid property', () => {
    const invalidProps = {
      scope: ScopeType.LIST,
      props: (_) => ({ test: "value", limit: 10, invalidProp: "error" }),
      api: () => {},
      type: "incorrect",
    };
    expect(() => validateApiProps(invalidProps)).toThrowError();
  });
});

अचूक परतावा प्रकार लागू करण्यासाठी टाइपस्क्रिप्ट धोरणे

सोबत काम करताना टाइपस्क्रिप्ट, कठोर मर्यादांसह रिटर्न प्रकार व्यवस्थापित केल्याने, विशेषत: जटिल कोडबेसमध्ये, अंदाज करण्यायोग्य API संरचना लागू करण्यात मदत होते. फंक्शन केवळ अनुमत गुणधर्म परत करते याची खात्री करण्याचा एक प्रभावी मार्ग म्हणजे सानुकूल उपयुक्तता प्रकार जे अचूक जुळणी लागू करतात. काम करताना हा दृष्टिकोन विशेषतः उपयुक्त आहे REST API किंवा विविध प्रतिसाद संरचनांसह जटिल अनुप्रयोग, कारण ते प्रतिसाद वस्तूंमध्ये अनपेक्षित जोडणे टाळण्यास मदत करते ज्यामुळे त्रुटी येऊ शकतात. जेनेरिक युटिलिटी प्रकार तयार करून, TypeScript डेव्हलपर हे सत्यापित करू शकतात की प्रत्येक API प्रतिसाद अपेक्षित संरचनेचे पालन करतो, API कॉल्स आणि प्रतिसाद हाताळणीमध्ये मजबूतता जोडतो.

अशा परिस्थितीत, conditional types अत्यावश्यक बनतात, वस्तूंच्या आकारांची तपासणी करण्यास परवानगी देते आणि अतिरिक्त गुणधर्म, जसे की अनपेक्षित १ मुख्य, प्रतिसादांमध्ये परिचय करून घेऊ नका. TypeScript या उद्देशासाठी शक्तिशाली साधने ऑफर करते, यासह mapped types आणि conditional types जे पूर्वनिर्धारित संरचनेच्या विरूद्ध मालमत्तेची नावे आणि प्रकार प्रमाणित करतात. मॅप केलेल्या प्रकारांसह, विकासक अचूक प्रकार जुळण्या लागू करू शकतात, तर सशर्त प्रकार दिलेल्या इनपुट प्रकारावर आधारित रिटर्न संरचना सुधारू शकतात. या रणनीती एकत्र केल्याने फंक्शन्स विविध स्कोप आणि API प्रतिसादांमध्ये सातत्याने वागतात याची खात्री करण्यात मदत होते.

याव्यतिरिक्त, चाचणी फ्रेमवर्क समाकलित करणे जसे Jest विकासकांना युनिट चाचण्यांसह TypeScript मर्यादा सत्यापित करण्यास अनुमती देते, कोड वेगवेगळ्या परिस्थितींमध्ये अपेक्षेप्रमाणे कार्य करतो याची खात्री करून. उदाहरणार्थ, अपेक्षित प्रकाराशी संबंधित नसलेली मालमत्ता दिसल्यास, जेस्ट चाचण्या ही समस्या ताबडतोब हायलाइट करू शकतात, ज्यामुळे विकासकांना विकास चक्रात लवकर त्रुटी कळू शकतात. स्टॅटिक प्रकार अंमलबजावणी आणि डायनॅमिक चाचणी या दोन्हींचा वापर केल्याने संघांना सुरक्षित, विश्वासार्ह ॲप्लिकेशन्स तयार करता येतात जे कठोर प्रकारच्या तपासण्या हाताळू शकतात, अधिक स्थिर API प्रतिसाद देतात आणि देखभालक्षमता सुधारतात. 🚀

TypeScript मध्ये प्रकार प्रतिबंध लागू करण्याबद्दल सामान्य प्रश्न

वापरून काय फायदा ५ API प्रतिसादांसाठी TypeScript मध्ये?
एनम्स विशिष्ट प्रकरणांमध्ये मूल्ये मर्यादित ठेवण्यास मदत करतात, ज्यामुळे सुसंगत API संरचना लागू करणे आणि अनपेक्षित इनपुटमधून त्रुटी टाळणे सोपे होते.
कसे करते EnforceExactKeys अचूक परताव्याच्या प्रकारांची खात्री करा?
द EnforceExactKeys युटिलिटी प्रकार तपासते की रिटर्न ऑब्जेक्टमध्ये फक्त निर्दिष्ट की अस्तित्वात आहेत आणि कोणत्याही अतिरिक्त की उपस्थित असल्यास ते टाइपस्क्रिप्ट त्रुटी टाकते.
मी वापरू शकतो conditional types TypeScript मध्ये रिटर्न प्रकार लागू करायचे?
होय, विशिष्ट परिस्थितींवर आधारित रिटर्न प्रकार लागू करण्यासाठी कंडिशनल प्रकार उपयुक्त आहेत, अपेक्षित संरचनांसह रिटर्न प्रकार अचूकपणे जुळण्यासाठी डायनॅमिक परंतु कठोर तपासणी करण्यास अनुमती देतात.
कसे करावे mapped types कठोर टायपिंगमध्ये योगदान द्या?
मॅप केलेले प्रकार अपेक्षित प्रकारात प्रत्येक की मॅप करून कठोर गुणधर्म आवश्यकता परिभाषित करतात, जे TypeScript ला ऑब्जेक्टची रचना त्या प्रकाराशी अचूकपणे संरेखित करण्याची अनुमती देते.
का आहेत unit tests TypeScript प्रकारांसह काम करताना महत्त्वाचे?
अनपेक्षित गुणधर्म किंवा प्रकार लवकर पकडले जातील याची खात्री करून, तुमच्या TypeScript कोडसाठी प्रमाणीकरणाचा दुसरा स्तर प्रदान करून, युनिट चाचण्या प्रमाणित करतात की प्रकार तपासण्या योग्यरित्या अंमलात आणल्या जातात.
कसे करू शकता ScopeType API प्रतिसाद वेगळे करण्यासाठी वापरले जाते?
ScopeType एक enum आहे जो प्रतिसादाने अनुसरण करावे की नाही हे निर्धारित करण्यात मदत करते LIST किंवा GENERIC रचना, एका फंक्शनमध्ये विविध API आवश्यकता व्यवस्थापित करणे सोपे करते.
सूची आणि जेनेरिक स्कोपमधील मुख्य फरक काय आहेत?
सूची व्याप्तीसाठी अतिरिक्त आवश्यक आहे १५ मालमत्ता त्याच्या रिटर्न प्रकारात, तर GENERIC अधिक लवचिक आहे आणि मूलभूत गुणधर्मांच्या पलीकडे अतिरिक्त की लागू करत नाही.
करू शकतो TypeScript एकाच फंक्शनमध्ये वेगवेगळे प्रकार हाताळायचे?
होय, TypeScript चे जेनेरिक प्रकार आणि उपयुक्तता प्रकार फंक्शनला अनेक प्रकार हाताळण्याची परवानगी देतात, परंतु सानुकूल प्रकार वापरून अचूक मर्यादा लागू करणे महत्त्वाचे आहे. १७ किंवा EnforceExactKeys.
ची भूमिका काय आहे props या सेटअप मध्ये कार्य?
द props फंक्शन प्रत्येक API प्रतिसादासाठी रिटर्न प्रकार परिभाषित करते, प्रत्येक प्रतिसादाचे गुणधर्म स्कोप (लिस्ट किंवा जेनेरिक) द्वारे परिभाषित केलेल्या प्रकारच्या आवश्यकतांशी जुळतात याची खात्री करते.
सह API प्रतिसाद प्रमाणित करणे शक्य आहे का २१?
TypeScript मजबूत कंपाइल-टाइम चेक प्रदान करते, परंतु वास्तविक परिस्थितीत वर्तनाची पुष्टी करण्यासाठी रनटाइम प्रमाणीकरण आणि जेस्ट सारख्या चाचणी फ्रेमवर्कचा वापर करण्याची शिफारस केली जाते.

TypeScript मध्ये प्रकार अंमलबजावणीचे अंतिम विचार:

TypeScript मधील कठोर प्रकारची अंमलबजावणी API प्रतिसादांमध्ये लुकणाऱ्या अनपेक्षित गुणधर्मांपासून एक शक्तिशाली संरक्षण प्रदान करते. एनम्स, मॅप केलेले प्रकार आणि उपयुक्तता प्रकार एकत्र करून, विकासक रिटर्न प्रकारांवर अचूक नियंत्रण मिळवतात, ज्यामुळे कोड वाचनीयता आणि स्थिरता सुधारते. हा दृष्टीकोन मोठ्या ऍप्लिकेशन्ससाठी आदर्श आहे जेथे संरचना महत्त्वपूर्ण आहे. 😊

मजबूत युनिट चाचणी समाविष्ट करणे, जसे की जेस्टसह, प्रमाणीकरणाचा अतिरिक्त स्तर प्रदान करते, हे सुनिश्चित करते की प्रकारच्या त्रुटी लवकर पकडल्या जातात. काळजीपूर्वक प्रकार व्यवस्थापनाची ही पातळी एक नितळ विकास अनुभव तयार करते आणि रनटाइम त्रुटी कमी करते, ज्यामुळे जटिल प्रकल्पांमध्ये टाइपस्क्रिप्ट विकसकांसाठी एक मौल्यवान धोरण बनते. 🚀

TypeScript प्रकार अंमलबजावणीसाठी पुढील वाचन आणि संदर्भ

मॅप केलेले आणि सशर्त प्रकार वापरून TypeScript प्रकारांमध्ये कठोर मालमत्ता निर्बंध लागू करण्यासाठी अंतर्दृष्टी: टाइपस्क्रिप्ट हँडबुक
TypeScript enums चे तपशीलवार स्पष्टीकरण आणि डेटा स्ट्रक्चरिंगमध्ये त्यांचा वापर: TypeScript enums दस्तऐवज
क्लिष्ट ऍप्लिकेशन्समधील प्रकारच्या मर्यादांच्या चाचणीसाठी टाइपस्क्रिप्टसह जेस्ट वापरण्याबाबत मार्गदर्शक तत्त्वे: विनोदी दस्तऐवजीकरण
मजबूत TypeScript अनुप्रयोग तयार करण्यासाठी उदाहरणे आणि सर्वोत्तम पद्धती: टाइपस्क्रिप्ट दस्तऐवजीकरण

TypeScript: Enum Validation सह रिटर्न टाईप मर्यादा लागू करणे