டெம்ப்ளேட் லிட்டரல் வகைகள்: டைப்ஸ்கிரிப்டில் சர மாதிரி பொருத்தம் மற்றும் சரிபார்ப்பு

டைப்ஸ்கிரிப்ட் வகை அமைப்பு தொடர்ந்து வளர்ந்து வருகிறது, இது சிக்கலான தர்க்கத்தை வெளிப்படுத்தவும் வகை பாதுகாப்பை உறுதிப்படுத்தவும் டெவலப்பர்களுக்கு அதிக சக்திவாய்ந்த கருவிகளை வழங்குகிறது. சமீபத்திய பதிப்புகளில் அறிமுகப்படுத்தப்பட்ட மிகவும் சுவாரஸ்யமான மற்றும் பல்துறை அம்சங்களில் ஒன்று டெம்ப்ளேட் லிட்டரல் வகைகள். இந்த வகைகள் வகை மட்டத்தில் சரங்களைக் கையாள உங்களை அனுமதிக்கின்றன, மேம்பட்ட சர மாதிரி பொருத்தம் மற்றும் சரிபார்ப்பை செயல்படுத்துகின்றன. இது மிகவும் வலுவான மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கான சாத்தியக்கூறுகளின் ஒரு புதிய உலகத்தைத் திறக்கிறது.

டெம்ப்ளேட் லிட்டரல் வகைகள் என்றால் என்ன?

டெம்ப்ளேட் லிட்டரல் வகைகள் என்பது சர லிட்டரல் வகைகள் மற்றும் யூனியன் வகைகளை ஒன்றிணைப்பதன் மூலம் கட்டியெழுப்பப்பட்ட ஒரு வகை வடிவமாகும், இது ஜாவாஸ்கிரிப்டில் டெம்ப்ளேட் லிட்டரல்கள் செயல்படுவதைப் போன்றது. இருப்பினும், இயக்க நேர சரங்களை உருவாக்குவதற்குப் பதிலாக, அவை ஏற்கனவே உள்ளவற்றின் அடிப்படையில் புதிய வகைகளை உருவாக்குகின்றன.

இதோ ஒரு அடிப்படை உதாரணம்:

            type Greeting<T extends string> = `Hello, ${T}!`;

type MyGreeting = Greeting<"World">; // type MyGreeting = "Hello, World!"

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `Greeting` என்பது டெம்ப்ளேட் லிட்டரல் வகையாகும், இது சர வகை `T` ஐ உள்ளீடாக எடுத்து "Hello, ", `T`, மற்றும் "!" ஆகியவற்றின் ஒரு புதிய வகையை வழங்குகிறது.

அடிப்படை சர மாதிரி பொருத்தம்

அடிப்படை சர மாதிரி பொருத்தத்தை செய்ய டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்தலாம். ஒரு குறிப்பிட்ட மாதிரியுடன் பொருந்தினால் மட்டுமே செல்லுபடியாகும் வகைகளை உருவாக்க இது உங்களை அனுமதிக்கிறது.

உதாரணமாக, "prefix-" இல் தொடங்கும் சரங்களை மட்டுமே ஏற்கும் ஒரு வகையை நீங்கள் உருவாக்கலாம்:

            type PrefixedString<T extends string> = T extends `prefix-${string}` ? T : never;

type ValidPrefixedString = PrefixedString<"prefix-valid">; // type ValidPrefixedString = "prefix-valid"
type InvalidPrefixedString = PrefixedString<"invalid">; // type InvalidPrefixedString = never

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `PrefixedString` ஒரு நிபந்தனை வகையைப் பயன்படுத்தி உள்ளீட்டு சரம் `T` "prefix-" இல் தொடங்குகிறதா என்று சரிபார்க்கிறது. அப்படிச் செய்தால், வகை `T` தானே; இல்லையெனில், அது `never`. `never` என்பது டைப்ஸ்கிரிப்டில் உள்ள ஒரு சிறப்பு வகையாகும், இது ஒருபோதும் ஏற்படாத மதிப்புகளின் வகையைக் குறிக்கிறது, திறம்பட தவறான சரத்தை விலக்குகிறது.

ஒரு சரத்தின் பகுதிகளை பிரித்தெடுத்தல்

டெம்ப்ளேட் லிட்டரல் வகைகளை சரத்தின் பகுதிகளைப் பிரித்தெடுக்கவும் பயன்படுத்தலாம். சரங்களிலிருந்து தரவைப் பாகுபடுத்தி அதை வெவ்வேறு வகைகளாக மாற்ற வேண்டியிருக்கும் போது இது மிகவும் பயனுள்ளதாக இருக்கும்.

உங்களிடம் "x:10,y:20" வடிவத்தில் ஒரு ஒருங்கிணைப்பை குறிக்கும் சரம் இருப்பதாக வைத்துக்கொள்வோம். x மற்றும் y மதிப்புகளைப் பிரித்தெடுக்க டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்தலாம்:

            type CoordinateString = `x:${number},y:${number}`;

type ExtractX<T extends CoordinateString> = T extends `x:${infer X},y:${number}` ? X : never;
type ExtractY<T extends CoordinateString> = T extends `x:${number},y:${infer Y}` ? Y : never;

type XValue = ExtractX<"x:10,y:20">; // type XValue = 10
type YValue = ExtractY<"x:10,y:20">; // type YValue = 20

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `ExtractX` மற்றும் `ExtractY` `number` வகையுடன் பொருந்தக்கூடிய சரத்தின் பகுதிகளைப் பிடிக்க `infer` முக்கிய சொல்லைப் பயன்படுத்துகின்றன. `infer` என்பது மாதிரி போட்டியிலிருந்து ஒரு வகையைப் பிரித்தெடுக்க உங்களை அனுமதிக்கிறது. கைப்பற்றப்பட்ட வகைகள் நிபந்தனை வகையின் திரும்பும் வகையாகப் பயன்படுத்தப்படுகின்றன.

மேம்பட்ட சர சரிபார்ப்பு

மேம்பட்ட சர சரிபார்ப்பை செய்ய டெம்ப்ளேட் லிட்டரல் வகைகளை யூனியன் வகைகள் மற்றும் நிபந்தனை வகைகள் போன்ற பிற டைப்ஸ்கிரிப்ட் அம்சங்களுடன் இணைக்க முடியும். சரங்களின் கட்டமைப்பு மற்றும் உள்ளடக்கத்தில் சிக்கலான விதிகளை செயல்படுத்தும் வகைகளை உருவாக்க இது உங்களை அனுமதிக்கிறது.

உதாரணமாக, ISO 8601 தேதி சரங்களை சரிபார்க்கும் வகையை நீங்கள் உருவாக்கலாம்:

            type Year = `${number}${number}${number}${number}`;
type Month = `0${number}` | `10` | `11` | `12`;
type Day = `${0}${number}` | `${1 | 2}${number}` | `30` | `31`;

type ISODate = `${Year}-${Month}-${Day}`;

type ValidDate = ISODate extends "2023-10-27" ? true : false; // true
type InvalidDate = ISODate extends "2023-13-27" ? true : false; // false

function processDate(date: ISODate) {
  // Function logic here.  TypeScript enforces the ISODate format.
  return `Processing date: ${date}`;
}

console.log(processDate("2024-01-15")); // Works
//console.log(processDate("2024-1-15")); // TypeScript error: Argument of type '"2024-1-15"' is not assignable to parameter of type '`${number}${number}${number}${number}-${0}${number}-${0}${number}` | `${number}${number}${number}${number}-${0}${number}-${1}${number}` | ... 14 more ... | `${number}${number}${number}${number}-12-31`'.

            

              
                Copy
              
            
          

இங்கே, `Year`, `Month`, மற்றும் `Day` ஆகியவை தேதியின் ஒவ்வொரு பகுதியின் செல்லுபடியாகும் வடிவங்களைக் குறிக்க டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்தி வரையறுக்கப்பட்டுள்ளன. `ISODate` பின்னர் இந்த வகைகளை ஒரு செல்லுபடியாகும் ISO 8601 தேதி சரத்தை பிரதிநிதித்துவப்படுத்தும் ஒரு வகையை உருவாக்க ஒருங்கிணைக்கிறது. இந்த வகை ஒரு செயல்பாட்டில் தரவு வடிவமைப்பை செயல்படுத்த எவ்வாறு பயன்படுத்தப்படலாம் என்பதையும் இந்த உதாரணம் காட்டுகிறது, தவறான தேதி வடிவங்கள் அனுப்பப்படுவதைத் தடுக்கிறது. இது குறியீடு நம்பகத்தன்மையை மேம்படுத்துகிறது மற்றும் தவறான உள்ளீட்டின் காரணமாக இயக்க நேர பிழைகளைத் தடுக்கிறது.

உண்மையான உலக பயன்பாட்டு நிகழ்வுகள்

டெம்ப்ளேட் லிட்டரல் வகைகளை பல்வேறு உண்மையான உலக காட்சிகளில் பயன்படுத்தலாம். சில எடுத்துக்காட்டுகள் இங்கே:

• படிவ சரிபார்ப்பு: மின்னஞ்சல் முகவரிகள், தொலைபேசி எண்கள் மற்றும் அஞ்சல் குறியீடுகள் போன்ற படிவ உள்ளீடுகளின் வடிவமைப்பை சரிபார்க்க டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்தலாம்.
• API கோரிக்கை சரிபார்ப்பு: API கோரிக்கை பேலோடுகளின் கட்டமைப்பை சரிபார்க்க டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்தலாம், அவை எதிர்பார்க்கப்படும் வடிவத்திற்கு இணங்குவதை உறுதிசெய்கின்றன. உதாரணமாக, நாணய குறியீட்டை சரிபார்த்தல் (எ.கா., "USD", "EUR", "GBP").
• கட்டமைவு கோப்பு பாகுபடுத்தல்: கட்டமைவு கோப்புகளைப் பாகுபடுத்தவும், குறிப்பிட்ட வடிவங்களின் அடிப்படையில் மதிப்புகளைப் பிரித்தெடுக்கவும் டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்தலாம். கட்டமைவு பொருளில் உள்ள கோப்பு பாதைகளை சரிபார்ப்பதைக் கவனியுங்கள்.
• சரம் அடிப்படையிலான எண்ணுருக்கள்: டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்தி சரிபார்ப்பு மூலம் சரம் அடிப்படையிலான எண்ணுருக்களை உருவாக்கலாம்.

உதாரணம்: நாணய குறியீடுகளை சரிபார்த்தல்

நாணய குறியீடுகளை சரிபார்ப்பதற்கான மிகவும் விரிவான உதாரணத்தை பார்ப்போம். எங்கள் பயன்பாட்டில் செல்லுபடியாகும் ISO 4217 நாணய குறியீடுகள் மட்டுமே பயன்படுத்தப்படுவதை உறுதிசெய்ய விரும்புகிறோம். இந்த குறியீடுகள் பொதுவாக மூன்று பெரிய எழுத்துக்கள்.

            type CurrencyCode = `${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`;

function formatCurrency(amount: number, currency: CurrencyCode) {
  // Function logic to format currency based on the provided code.
  return `$${amount} ${currency}`;
}

console.log(formatCurrency(100, "USD")); // Works
//console.log(formatCurrency(100, "usd")); // TypeScript error: Argument of type '"usd"' is not assignable to parameter of type '`${Uppercase}${Uppercase}${Uppercase}`'.

//More precise example:
type ValidCurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"; // Extend as needed

type StronglyTypedCurrencyCode = ValidCurrencyCode;

function formatCurrencyStronglyTyped(amount: number, currency: StronglyTypedCurrencyCode) {
    return `$${amount} ${currency}`;
}

console.log(formatCurrencyStronglyTyped(100, "EUR")); // Works
//console.log(formatCurrencyStronglyTyped(100, "CNY")); // TypeScript error: Argument of type '"CNY"' is not assignable to parameter of type '"USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"'.

            

              
                Copy
              
            
          

மூன்று பெரிய எழுத்துக்களைக் கொண்ட சரங்களை மட்டுமே ஏற்கும் `CurrencyCode` வகையை எவ்வாறு உருவாக்குவது என்பதை இந்த உதாரணம் காட்டுகிறது. இரண்டாவது, மிகவும் வலுவாக தட்டச்சு செய்யப்பட்ட உதாரணம், இதை ஏற்றுக்கொள்ளக்கூடிய நாணயங்களின் முன் வரையறுக்கப்பட்ட பட்டியலுக்கு இன்னும் எவ்வாறு கட்டுப்படுத்துவது என்பதைக் காட்டுகிறது.

உதாரணம்: API எண்ட்பாயிண்ட் பாதைகளை சரிபார்த்தல்

மற்றொரு பயன்பாட்டு நிகழ்வு API எண்ட்பாயிண்ட் பாதைகளை சரிபார்க்கிறது. சரியான பாதைகளுக்கு கோரிக்கைகள் செய்யப்படுவதை உறுதிசெய்து, செல்லுபடியாகும் API எண்ட்பாயிண்ட் கட்டமைப்பைக் குறிக்கும் வகையை நீங்கள் வரையறுக்கலாம். மைக்ரோசர்வீஸ் கட்டமைப்புகளில் இது மிகவும் பயனுள்ளதாக இருக்கும், அங்கு பல சேவைகள் வெவ்வேறு APIகளை வெளிப்படுத்தலாம்.

            type APIServiceName = "users" | "products" | "orders";
type APIEndpointPath = `/${APIServiceName}/${string}`;

function callAPI(path: APIEndpointPath) {
  // API call logic
  console.log(`Calling API: ${path}`);
}

callAPI("/users/123"); // Valid
callAPI("/products/details"); // Valid
//callAPI("/invalid/path"); // TypeScript error

// Even more specific:
type APIAction = "create" | "read" | "update" | "delete";
type APIEndpointPathSpecific = `/${APIServiceName}/${APIAction}`;

function callAPISpecific(path: APIEndpointPathSpecific) {
  // API call logic
  console.log(`Calling specific API: ${path}`);
}

callAPISpecific("/users/create"); // Valid
//callAPISpecific("/users/list"); // TypeScript error

            

              
                Copy
              
            
          

இது உங்கள் பயன்பாட்டில் பிழைகளைத் தடுத்து, நிலைத்தன்மையை உறுதிசெய்து, API எண்ட்பாயிண்டுகளின் கட்டமைப்பை இன்னும் துல்லியமாக வரையறுக்க உங்களை அனுமதிக்கிறது. இது ஒரு அடிப்படை உதாரணம்; வினவல் அளவுருக்கள் மற்றும் URL இன் பிற பகுதிகளை சரிபார்க்க மிகவும் சிக்கலான வடிவங்களை உருவாக்க முடியும்.

டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்துவதன் நன்மைகள்

சர மாதிரி பொருத்தம் மற்றும் சரிபார்ப்புக்காக டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்துவது பல நன்மைகளை வழங்குகிறது:

• மேம்படுத்தப்பட்ட வகை பாதுகாப்பு: டெம்ப்ளேட் லிட்டரல் வகைகள் சரங்களில் கடுமையான வகை தடைகளை செயல்படுத்த உங்களை அனுமதிக்கின்றன, இயக்க நேர பிழைகளின் அபாயத்தை குறைக்கின்றன.
• மேம்படுத்தப்பட்ட குறியீடு வாசிப்புத்திறன்: சரங்களின் எதிர்பார்க்கப்படும் வடிவமைப்பை தெளிவாக வெளிப்படுத்துவதன் மூலம் டெம்ப்ளேட் லிட்டரல் வகைகள் உங்கள் குறியீட்டை மேலும் படிக்கக்கூடியதாக ஆக்குகின்றன.
• அதிகரித்த பராமரிப்பு: சரம் சரிபார்ப்பு விதிகளுக்கு ஒரு ஆதாரத்தை வழங்குவதன் மூலம் டெம்ப்ளேட் லிட்டரல் வகைகள் உங்கள் குறியீட்டை மேலும் பராமரிக்கக்கூடியதாக ஆக்குகின்றன.
• சிறந்த டெவலப்பர் அனுபவம்: டெம்ப்ளேட் லிட்டரல் வகைகள் சிறந்த தன்னியக்க நிரப்புதல் மற்றும் பிழை செய்திகளை வழங்குகின்றன, ஒட்டுமொத்த டெவலப்பர் அனுபவத்தை மேம்படுத்துகின்றன.

வரம்புகள்

டெம்ப்ளேட் லிட்டரல் வகைகள் சக்திவாய்ந்ததாக இருந்தாலும், அவற்றுக்கு சில வரம்புகளும் உள்ளன:

• சிக்கலானது: டெம்ப்ளேட் லிட்டரல் வகைகள் சிக்கலான வடிவங்களுடன் பணிபுரியும் போது குறிப்பாக சிக்கலானதாக மாறும். குறியீடு பராமரிப்புடன் வகை பாதுகாப்பின் நன்மைகளை சமநிலைப்படுத்துவது அவசியம்.
• செயல்திறன்: டெம்ப்ளேட் லிட்டரல் வகைகள் தொகுப்பு செயல்திறனை பாதிக்கலாம், குறிப்பாக பெரிய திட்டங்களில். ஏனென்றால் டைப்ஸ்கிரிப்ட் அதிக சிக்கலான வகை சரிபார்ப்பைச் செய்ய வேண்டும்.
• வரையறுக்கப்பட்ட வழக்கமான வெளிப்பாடு ஆதரவு: டெம்ப்ளேட் லிட்டரல் வகைகள் மாதிரி பொருத்தத்தை அனுமதிக்கும்போது, அவை வழக்கமான வெளிப்பாடு அம்சங்களின் முழு அளவையும் ஆதரிக்காது. அதிக சிக்கலான சரம் சரிபார்ப்புக்கு, சரியான உள்ளீடு சுத்திகரிப்புக்காக இந்த வகை கட்டமைப்புகளுடன் இயக்க நேர வழக்கமான வெளிப்பாடுகளும் தேவைப்படலாம்.

சிறந்த நடைமுறைகள்

டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்தும் போது மனதில் கொள்ள வேண்டிய சில சிறந்த நடைமுறைகள் இங்கே:

• எளிமையாகத் தொடங்கவும்: எளிய வடிவங்களுடன் தொடங்கி, தேவைக்கேற்ப படிப்படியாக சிக்கலை அதிகரிக்கவும்.
• விளக்கமான பெயர்களைப் பயன்படுத்தவும்: குறியீடு வாசிப்புத்திறனை மேம்படுத்த உங்கள் டெம்ப்ளேட் லிட்டரல் வகைகளுக்கு விளக்கமான பெயர்களைப் பயன்படுத்தவும்.
• உங்கள் வகைகளை ஆவணப்படுத்தவும்: உங்கள் டெம்ப்ளேட் லிட்டரல் வகைகளின் நோக்கம் மற்றும் பயன்பாட்டை விளக்க அவற்ற ஆவணப்படுத்தவும்.
• முழுமையாக சோதிக்கவும்: உங்கள் டெம்ப்ளேட் லிட்டரல் வகைகள் எதிர்பார்த்தபடி செயல்படுவதை உறுதிசெய்ய அவற்றை முழுமையாக சோதிக்கவும்.
• செயல்திறனைக் கவனியுங்கள்: தொகுப்பு செயல்திறனில் டெம்ப்ளேட் லிட்டரல் வகைகளின் தாக்கத்தைக் கவனியுங்கள், அதற்கேற்ப உங்கள் குறியீட்டை மேம்படுத்தவும்.

முடிவுரை

டெம்ப்ளேட் லிட்டரல் வகைகள் டைப்ஸ்கிரிப்டில் உள்ள ஒரு சக்திவாய்ந்த அம்சமாகும், இது வகை மட்டத்தில் மேம்பட்ட சர கையாளுதல், மாதிரி பொருத்தம் மற்றும் சரிபார்ப்பை செய்ய உங்களை அனுமதிக்கிறது. டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்துவதன் மூலம், நீங்கள் மிகவும் வலுவான, பராமரிக்கக்கூடிய மற்றும் வகை-பாதுகாப்பான பயன்பாடுகளை உருவாக்க முடியும். அவற்றுக்கு சில வரம்புகள் இருந்தாலும், டெம்ப்ளேட் லிட்டரல் வகைகளைப் பயன்படுத்துவதன் நன்மைகள் குறைபாடுகளை விட அதிகமாக இருக்கும், அவை எந்த டைப்ஸ்கிரிப்ட் டெவலப்பரின் ஆயுதக் களஞ்சியத்திலும் மதிப்புமிக்க கருவியாக இருக்கும். டைப்ஸ்கிரிப்ட் மொழி தொடர்ந்து வளர்ச்சியடைந்து வருவதால், இந்த மேம்பட்ட வகை அம்சங்களைப் புரிந்துகொள்வது மற்றும் பயன்படுத்துவது உயர்தர மென்பொருளை உருவாக்குவதற்கு முக்கியமானதாக இருக்கும். சிக்கலை வாசிப்புத்திறனுடன் சமநிலைப்படுத்தவும், எப்போதும் முழுமையான சோதனைக்கு முன்னுரிமை கொடுக்கவும் நினைவில் கொள்ளுங்கள்.