ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಮಾದರಿ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಮೌಲ್ಯಾಂಕನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಸಿಸ್ಟಮ್ ನಿರಂತರವಾಗಿ ವಿಕಸನಗೊಳ್ಳುತ್ತಿದೆ, ಇದು ಸಂಕೀರ್ಣ ತರ್ಕವನ್ನು ವ್ಯಕ್ತಪಡಿಸಲು ಮತ್ತು ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ಸಾಧನಗಳನ್ನು ನೀಡುತ್ತದೆ. ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಮತ್ತು ಬಹುಮುಖ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು. ಈ ಟೈಪ್‌ಗಳು ಟೈಪ್ ಹಂತದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಸುಧಾರಿತ ಸ್ಟ್ರಿಂಗ್ ಮಾದರಿ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಮೌಲ್ಯಾಂಕನವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಇದು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಸಾಧ್ಯತೆಗಳ ಒಂದು ಹೊಸ ಜಗತ್ತನ್ನು ತೆರೆಯುತ್ತದೆ.

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಎಂದರೇನು?

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಎನ್ನುವುದು ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಮತ್ತು ಯೂನಿಯನ್ ಟೈಪ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ನಿರ್ಮಿಸಲಾದ ಒಂದು ರೀತಿಯ ಟೈಪ್, ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದಕ್ಕೆ ಹೋಲುತ್ತದೆ. ಆದಾಗ್ಯೂ, ರನ್‌ಟೈಮ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ರಚಿಸುವ ಬದಲು, ಅವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವವುಗಳ ಆಧಾರದ ಮೇಲೆ ಹೊಸ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸುತ್ತವೆ.

ಇಲ್ಲಿ ಒಂದು ಮೂಲ ಉದಾಹರಣೆ ಇದೆ:

            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
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ `T` "prefix-" ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು `PrefixedString` ನಿಯಮಾಧೀನ ಟೈಪ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಅದು ಮಾಡಿದರೆ, ಟೈಪ್ `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 ನ ಇತರ ಭಾಗಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಮಾದರಿಗಳನ್ನು ರಚಿಸಬಹುದು.

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಆಗುವ ಪ್ರಯೋಜನಗಳು

ಸ್ಟ್ರಿಂಗ್ ಮಾದರಿ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಮೌಲ್ಯಾಂಕನಕ್ಕಾಗಿ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುವುದು ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ:

• ಸುಧಾರಿತ ಟೈಪ್ ಸುರಕ್ಷತೆ: ರನ್‌ಟೈಮ್ ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಮೇಲೆ ಕಟ್ಟುನಿಟ್ಟಾದ ಟೈಪ್ ನಿರ್ಬಂಧಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ.
• ವರ್ಧಿತ ಕೋಡ್ ಓದಲು ಸಾಧ್ಯವಾಗುವುದು: ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಸ್ಟ್ರಿಂಗ್‌ಗಳ ನಿರೀಕ್ಷಿತ ಸ್ವರೂಪವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಕ್ತಪಡಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ.
• ಹೆಚ್ಚಿದ ನಿರ್ವಹಣೆ: ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಾಂಕನ ನಿಯಮಗಳಿಗಾಗಿ ಏಕೈಕ ಮೂಲವನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ನಿರ್ವಹಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.
• ಉತ್ತಮ ಡೆವಲಪರ್ ಅನುಭವ: ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಉತ್ತಮ ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಮತ್ತು ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ಒಟ್ಟಾರೆ ಡೆವಲಪರ್ ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ಮಿತಿಗಳು

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ಅವು ಕೆಲವು ಮಿತಿಗಳನ್ನು ಸಹ ಹೊಂದಿವೆ:

• ಸಂಕೀರ್ಣತೆ: ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಸಂಕೀರ್ಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಜಟಿಲವಾದ ಮಾದರಿಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ. ಟೈಪ್ ಸುರಕ್ಷತೆಯ ಪ್ರಯೋಜನಗಳನ್ನು ಕೋಡ್ ನಿರ್ವಹಣೆಯೊಂದಿಗೆ ಸಮತೋಲನಗೊಳಿಸುವುದು ಬಹಳ ಮುಖ್ಯ.
• ಕಾರ್ಯಕ್ಷಮತೆ: ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಕಂಪೈಲ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಏಕೆಂದರೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಟೈಪ್ ಪರಿಶೀಲನೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ.
• ಸೀಮಿತ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಬೆಂಬಲ: ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಮಾದರಿ ಹೊಂದಾಣಿಕೆಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟರೂ, ಅವು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ವೈಶಿಷ್ಟ್ಯಗಳ ಸಂಪೂರ್ಣ ಶ್ರೇಣಿಯನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ. ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಾಂಕನಕ್ಕಾಗಿ, ಸರಿಯಾದ ಇನ್‌ಪುಟ್ ಸ್ಯಾನಿಟೈಸೇಶನ್‌ಗಾಗಿ ಈ ಟೈಪ್ ರಚನೆಗಳ ಜೊತೆಗೆ ರನ್‌ಟೈಮ್ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಇನ್ನೂ ಬೇಕಾಗಬಹುದು.

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುವಾಗ ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• ಸರಳವಾಗಿ ಪ್ರಾರಂಭಿಸಿ: ಸರಳ ಮಾದರಿಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಅಗತ್ಯವಿರುವಂತೆ ಕ್ರಮೇಣ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೆಚ್ಚಿಸಿ.
• ವಿವರಣಾತ್ಮಕ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ: ಕೋಡ್ ಓದಲು ಸಾಧ್ಯವಾಗುವಂತೆ ನಿಮ್ಮ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳಿಗಾಗಿ ವಿವರಣಾತ್ಮಕ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ.
• ನಿಮ್ಮ ಟೈಪ್‌ಗಳನ್ನು ದಸ್ತಾವೇಜು ಮಾಡಿ: ಅವುಗಳ ಉದ್ದೇಶ ಮತ್ತು ಬಳಕೆಯನ್ನು ವಿವರಿಸಲು ನಿಮ್ಮ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳನ್ನು ದಸ್ತಾವೇಜು ಮಾಡಿ.
• ಸಮಗ್ರವಾಗಿ ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ನಿರೀಕ್ಷೆಯಂತೆ ವರ್ತಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅವುಗಳನ್ನು ಸಮಗ್ರವಾಗಿ ಪರೀಕ್ಷಿಸಿ.
• ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಗಣಿಸಿ: ಕಂಪೈಲ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳ ಪ್ರಭಾವದ ಬಗ್ಗೆ ಗಮನವಿರಲಿ ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ.

ತೀರ್ಮಾನ

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಪ್ರಬಲ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು ಅದು ಟೈಪ್ ಹಂತದಲ್ಲಿ ಸುಧಾರಿತ ಸ್ಟ್ರಿಂಗ್ ಕುಶಲತೆ, ಮಾದರಿ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಮೌಲ್ಯಾಂಕನವನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದೃಢವಾದ, ನಿರ್ವಹಿಸಬಹುದಾದ ಮತ್ತು ಟೈಪ್-ಸುರಕ್ಷಿತ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ಅವು ಕೆಲವು ಮಿತಿಗಳನ್ನು ಹೊಂದಿದ್ದರೂ, ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಆಗುವ ಪ್ರಯೋಜನಗಳು ಸಾಮಾನ್ಯವಾಗಿ ನ್ಯೂನತೆಗಳನ್ನು ಮೀರಿಸುತ್ತದೆ, ಅವುಗಳನ್ನು ಯಾವುದೇ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ನ ಆಯುಧಾಗಾರದಲ್ಲಿ ಒಂದು ಅಮೂಲ್ಯ ಸಾಧನವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆ ವಿಕಸನಗೊಳ್ಳುವುದನ್ನು ಮುಂದುವರಿಸುವುದರಿಂದ, ಈ ಸುಧಾರಿತ ಟೈಪ್ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಬಳಸುವುದು ಉತ್ತಮ ಗುಣಮಟ್ಟದ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ನಿರ್ಣಾಯಕವಾಗುತ್ತದೆ. ಸಂಕೀರ್ಣತೆಯನ್ನು ಓದಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಸಮತೋಲನಗೊಳಿಸಲು ಮರೆಯದಿರಿ ಮತ್ತು ಯಾವಾಗಲೂ ಸಮಗ್ರ ಪರೀಕ್ಷೆಗೆ ಆದ್ಯತೆ ನೀಡಿ.