டைப்ஸ்கிரிப்ட் ஜெனரிக்ஸ்: வலுவான பயன்பாடுகளுக்காக சிக்கலான தரவு வகைகளில் தேர்ச்சி பெறுதல்

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

ஜெனரிக்ஸ் என்றால் என்ன?

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

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

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

ஜெனரிக்ஸின் அடிப்படை தொடரியல்

ஜெனரிக்ஸின் அடிப்படை தொடரியல், வகை அளவுருக்களை அறிவிக்க கோண அடைப்புக்குறிகளை (< >) பயன்படுத்துவதை உள்ளடக்கியது. இந்த வகை அளவுருக்கள் பொதுவாக T, K, V, போன்றவற்றிற்குப் பெயரிடப்படுகின்றன, ஆனால் நீங்கள் எந்தவொரு சரியான அடையாளத்தையும் பயன்படுத்தலாம். இங்கே ஒரு பொதுவான செயல்பாட்டின் எளிய எடுத்துக்காட்டு:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);
let myBoolean: boolean = identity<boolean>(true);

console.log(myString); // Output: hello
console.log(myNumber); // Output: 123
console.log(myBoolean); // Output: true

இந்த எடுத்துக்காட்டில், <T> என்பது T என்ற பெயரில் ஒரு வகை அளவுருவை அறிவிக்கிறது. identity செயல்பாடு T வகையின் ஒரு ஆர்குமென்ட்டை எடுத்து T வகையின் மதிப்பை வழங்குகிறது. செயல்பாட்டை அழைக்கும் போது, நீங்கள் வகை அளவுருவை வெளிப்படையாகக் குறிப்பிடலாம் (எ.கா., identity<string>) அல்லது ஆர்குமென்ட் வகையின் அடிப்படையில் டைப்ஸ்கிரிப்ட்டை அனுமானிக்க அனுமதிக்கலாம்.

சிக்கலான தரவு வகைகளுடன் வேலை செய்தல்

அரேக்கள், ஆப்ஜெக்ட்கள் மற்றும் இன்டர்ஃபேஸ்கள் போன்ற சிக்கலான தரவு வகைகளைக் கையாளும் போது ஜெனரிக்ஸ் மிகவும் மதிப்புமிக்கதாகிறது. சில பொதுவான காட்சிகளை ஆராய்வோம்:

ஜெனரிக் அரேக்கள்

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

function arrayToString<T>(arr: T[]): string {
  return arr.join(", ");
}

let numberArray: number[] = [1, 2, 3, 4, 5];
let stringArray: string[] = ["apple", "banana", "cherry"];

console.log(arrayToString(numberArray)); // Output: 1, 2, 3, 4, 5
console.log(arrayToString(stringArray)); // Output: apple, banana, cherry

இங்கே, arrayToString செயல்பாடு T[] வகையின் ஒரு அரேவை எடுத்து, அந்த அரேவின் ஒரு ஸ்டிரிங் பிரதிநிதித்துவத்தை வழங்குகிறது. இந்தச் செயல்பாடு எந்த வகையின் அரேக்களுடனும் வேலை செய்யும், இது அதிக மறுபயன்பாட்டிற்குரியதாக ஆக்குகிறது.

ஜெனரிக் ஆப்ஜெக்ட்கள்

பல்வேறு வடிவங்களில் உள்ள ஆப்ஜெக்ட்களுடன் வேலை செய்யும் செயல்பாடுகள் அல்லது வகுப்புகளை வரையறுக்கவும் ஜெனரிக்ஸ் பயன்படுத்தப்படலாம்:

interface Person {
  name: string;
  age: number;
  country: string; // Added country for global context
}

interface Product {
  id: number;
  name: string;
  price: number;
  currency: string; // Added currency for global context
}

function displayInfo<T extends { name: string }>(item: T): void {
  console.log(`Name: ${item.name}`);
}

let person: Person = { name: "Alice", age: 30, country: "USA" };
let product: Product = { id: 1, name: "Laptop", price: 1200, currency: "USD" };

displayInfo(person); // Output: Name: Alice
displayInfo(product); // Output: Name: Laptop

இந்த எடுத்துக்காட்டில், displayInfo செயல்பாடு T வகையின் ஒரு ஆப்ஜெக்ட்டை எடுக்கிறது, அது ஸ்டிரிங் வகையின் name என்ற பண்பைக் கொண்டிருக்க வேண்டும். extends { name: string } என்ற பிரிவு ஒரு கட்டுப்பாடு ஆகும், இது வகை அளவுரு T-க்கான குறைந்தபட்ச தேவைகளைக் குறிப்பிடுகிறது. இது செயல்பாடு name பண்பை பாதுகாப்பாக அணுக முடியும் என்பதை உறுதி செய்கிறது.

மேம்பட்ட ஜெனரிக் பயன்பாடு

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

பல வகை அளவுருக்கள்

நீங்கள் பல வகை அளவுருக்களுடன் செயல்பாடுகள் அல்லது வகுப்புகளை வரையறுக்கலாம்:

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

interface Name {
  firstName: string;
}

interface Age {
  age: number;
}

const person: Name = { firstName: "Bob" };
const details: Age = { age: 42 };

const merged = merge(person, details);
console.log(merged.firstName); // Output: Bob
console.log(merged.age); // Output: 42

merge செயல்பாடு T மற்றும் U வகைகளின் இரண்டு ஆப்ஜெக்ட்களை எடுத்து, இரு ஆப்ஜெக்ட்களின் பண்புகளையும் கொண்ட ஒரு புதிய ஆப்ஜெக்ட்டை வழங்குகிறது. இது வெவ்வேறு மூலங்களிலிருந்து தரவை இணைப்பதற்கான ஒரு சக்திவாய்ந்த வழியாகும்.

ஜெனரிக் கட்டுப்பாடுகள்

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

interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

loggingIdentity([1, 2, 3]); // Output: 3
loggingIdentity("hello"); // Output: 5
// loggingIdentity(123); // Error: Argument of type 'number' is not assignable to parameter of type 'Lengthwise'.

loggingIdentity செயல்பாடு T வகையின் ஒரு ஆர்குமென்ட்டை எடுக்கிறது, அது எண் வகையின் length என்ற பண்பைக் கொண்டிருக்க வேண்டும். இது செயல்பாடு length பண்பை பாதுகாப்பாக அணுக முடியும் என்பதை உறுதி செய்கிறது.

ஜெனரிக் வகுப்புகள்

ஜெனரிக்ஸ் வகுப்புகளுடனும் பயன்படுத்தப்படலாம்:

class DataStorage<T> {
  private data: T[] = [];

  addItem(item: T) {
    this.data.push(item);
  }

  removeItem(item: T) {
    this.data = this.data.filter(d => d !== item);
  }

  getItems(): T[] {
    return [...this.data];
  }
}

const textStorage = new DataStorage<string>();
textStorage.addItem("apple");
textStorage.addItem("banana");
textStorage.removeItem("apple");
console.log(textStorage.getItems()); // Output: [ 'banana' ]

const numberStorage = new DataStorage<number>();
numberStorage.addItem(1);
numberStorage.addItem(2);
numberStorage.removeItem(1);
console.log(numberStorage.getItems()); // Output: [ 2 ]

DataStorage வகுப்பு எந்த வகை T-யின் தரவையும் சேமிக்க முடியும். இது வகை-பாதுகாப்பான, மீண்டும் பயன்படுத்தக்கூடிய தரவுக் கட்டமைப்புகளை உருவாக்க உங்களை அனுமதிக்கிறது.

ஜெனரிக் இன்டர்ஃபேஸ்கள்

வெவ்வேறு வகைகளுடன் வேலை செய்யக்கூடிய ஒப்பந்தங்களை வரையறுக்க ஜெனரிக் இன்டர்ஃபேஸ்கள் பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டாக:

interface Result<T, E> {
  success: boolean;
  data?: T;
  error?: E;
}

interface User {
  id: number;
  username: string;
  email: string;
}

interface ErrorMessage {
  code: number;
  message: string;
}

function fetchUser(id: number): Result<User, ErrorMessage> {
  if (id === 1) {
    return { success: true, data: { id: 1, username: "john.doe", email: "john.doe@example.com" } };
  } else {
    return { success: false, error: { code: 404, message: "User not found" } };
  }
}

const userResult = fetchUser(1);
if (userResult.success) {
  console.log(userResult.data.username);
} else {
  console.log(userResult.error.message);
}

Result இன்டர்ஃபேஸ் ஒரு செயல்பாட்டின் விளைவைக் குறிக்க ஒரு பொதுவான கட்டமைப்பை வரையறுக்கிறது. இது T வகையின் தரவைக் கொண்டிருக்கலாம் அல்லது E வகையின் பிழையைக் கொண்டிருக்கலாம். இது ஒத்திசைவற்ற செயல்பாடுகள் அல்லது தோல்வியடையக்கூடிய செயல்பாடுகளைக் கையாள்வதற்கான ஒரு பொதுவான வடிவமாகும்.

பயன்பாட்டு வகைகள் மற்றும் ஜெனரிக்ஸ்

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

Partial<T>

Partial<T> என்பது T வகையின் அனைத்து பண்புகளையும் விருப்பமானதாக ஆக்குகிறது:

interface Person {
  name: string;
  age: number;
}

type PartialPerson = Partial<Person>;

const partialPerson: PartialPerson = { name: "Alice" }; // Valid

Readonly<T>

Readonly<T> என்பது T வகையின் அனைத்து பண்புகளையும் படிக்க மட்டுமே கூடியதாக (readonly) ஆக்குகிறது:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = Readonly<Person>;

const readonlyPerson: ReadonlyPerson = { name: "Bob", age: 42 };
// readonlyPerson.age = 43; // Error: Cannot assign to 'age' because it is a read-only property.

Pick<T, K>

Pick<T, K> என்பது T வகையிலிருந்து K என்ற பண்புகளின் தொகுப்பைத் தேர்ந்தெடுக்கிறது:

interface Person {
  name: string;
  age: number;
  email: string;
}

type NameAndAge = Pick<Person, "name" | "age">;

const nameAndAge: NameAndAge = { name: "Charlie", age: 28 };

Omit<T, K>

Omit<T, K> என்பது T வகையிலிருந்து K என்ற பண்புகளின் தொகுப்பை நீக்குகிறது:

interface Person {
  name: string;
  age: number;
  email: string;
}

type PersonWithoutEmail = Omit<Person, "email">;

const personWithoutEmail: PersonWithoutEmail = { name: "David", age: 35 };

Record<K, T>

Record<K, T> என்பது K விசைகளையும் T வகையின் மதிப்புகளையும் கொண்ட ஒரு வகையை உருவாக்குகிறது:

type CountryCodes = "US" | "CA" | "UK" | "DE" | "FR" | "JP" | "CN" | "IN" | "BR" | "AU"; // Expanded list for global context
type Currency = "USD" | "CAD" | "GBP" | "EUR" | "JPY" | "CNY" | "INR" | "BRL" | "AUD"; // Expanded list for global context

type CurrencyMap = Record<CountryCodes, Currency>;

const currencyMap: CurrencyMap = {
  "US": "USD",
  "CA": "CAD",
  "UK": "GBP",
  "DE": "EUR",
  "FR": "EUR",
  "JP": "JPY",
  "CN": "CNY",
  "IN": "INR",
  "BR": "BRL",
  "AU": "AUD",
};

மேப் செய்யப்பட்ட வகைகள்

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

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = {
  readonly [K in keyof Person]: Person[K];
};

const readonlyPerson: ReadonlyPerson = { name: "Eve", age: 25 };
// readonlyPerson.age = 26; // Error: Cannot assign to 'age' because it is a read-only property.

இந்த எடுத்துக்காட்டில், [K in keyof Person] என்பது Person இன்டர்ஃபேஸின் அனைத்து விசைகளையும் மீண்டும் மீண்டும் செய்கிறது, மேலும் Person[K] ஒவ்வொரு பண்பின் வகையையும் அணுகுகிறது. readonly என்ற முக்கியச்சொல் ஒவ்வொரு பண்பையும் படிக்க மட்டுமே கூடியதாக மாற்றுகிறது.

நிபந்தனை வகைகள்

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

type NonNullable<T> = T extends null | undefined ? never : T;

type MaybeString = string | null | undefined;
type StringType = NonNullable<MaybeString>; // string

function getValue<T>(value: T): NonNullable<T> {
  if (value == null) { // Handles both null and undefined
    throw new Error("Value cannot be null or undefined");
  }
  return value as NonNullable<T>;
}

try {
  const validValue = getValue("hello");
  console.log(validValue.toUpperCase()); // Output: HELLO

  const invalidValue = getValue(null); // This will throw an error
  console.log(invalidValue); // This line will not be reached
} catch (error: any) {
  console.error(error.message); // Output: Value cannot be null or undefined
}

இந்த எடுத்துக்காட்டில், NonNullable<T> வகை T என்பது null அல்லது undefined ஆக உள்ளதா என்று சரிபார்க்கிறது. அவ்வாறு இருந்தால், அது never என்று வழங்குகிறது, அதாவது அந்த வகை அனுமதிக்கப்படவில்லை. இல்லையெனில், அது T என்று வழங்குகிறது. இது null அல்லாததாக உத்தரவாதம் அளிக்கப்பட்ட வகைகளை உருவாக்க உங்களை அனுமதிக்கிறது.

ஜெனரிக்ஸைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

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

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

உலகளாவிய சூழலில் எடுத்துக்காட்டுகள்

உலகளாவிய சூழலில் ஜெனரிக்ஸ் எவ்வாறு பயன்படுத்தப்படலாம் என்பதற்கான சில எடுத்துக்காட்டுகளைக் கருத்தில் கொள்வோம்:

நாணய மாற்றுதல்

interface ConversionRate {
  rate: number;
  fromCurrency: string;
  toCurrency: string;
}

function convertCurrency<T extends ConversionRate>(amount: number, rate: T): number {
  return amount * rate.rate;
}

const usdToEurRate: ConversionRate = { rate: 0.85, fromCurrency: "USD", toCurrency: "EUR" };
const amountInUSD = 100;
const amountInEUR = convertCurrency(amountInUSD, usdToEurRate);
console.log(`${amountInUSD} USD is equal to ${amountInEUR} EUR`); // Output: 100 USD is equal to 85 EUR

தேதி வடிவமைத்தல்

interface DateFormatOptions {
  locale: string;
  options: Intl.DateTimeFormatOptions;
}

function formatDate<T extends DateFormatOptions>(date: Date, format: T): string {
  return date.toLocaleDateString(format.locale, format.options);
}

const currentDate = new Date();

const usDateFormat: DateFormatOptions = { locale: "en-US", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const germanDateFormat: DateFormatOptions = { locale: "de-DE", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const japaneseDateFormat: DateFormatOptions = { locale: "ja-JP", options: { year: 'numeric', month: 'long', day: 'numeric' } };

console.log("US Date: " + formatDate(currentDate, usDateFormat));
console.log("German Date: " + formatDate(currentDate, germanDateFormat));
console.log("Japanese Date: " + formatDate(currentDate, japaneseDateFormat));

மொழிபெயர்ப்பு சேவை

interface Translation {
  [key: string]: string; // Allows for dynamic language keys
}

interface LanguageData<T extends Translation> {
  languageCode: string;
  translations: T;
}

const englishTranslations: Translation = {
  "hello": "Hello",
  "goodbye": "Goodbye",
  "welcome": "Welcome to our website!"
};

const spanishTranslations: Translation = {
  "hello": "Hola",
  "goodbye": "Adiós",
  "welcome": "¡Bienvenido a nuestro sitio web!"
};

const frenchTranslations: Translation = {
  "hello": "Bonjour",
  "goodbye": "Au revoir",
  "welcome": "Bienvenue sur notre site web !"
};


const languageData: LanguageData<typeof englishTranslations>[] = [
  {languageCode: "en", translations: englishTranslations },
  {languageCode: "es", translations: spanishTranslations },
  {languageCode: "fr", translations: frenchTranslations}
];

function translate<T extends Translation>(key: string, languageCode: string, languageData: LanguageData<T>[]): string {
  const lang = languageData.find(lang => lang.languageCode === languageCode);
  if (!lang) {
    return `Translation for ${key} in ${languageCode} not found.`;
  }
  return lang.translations[key] || `Translation for ${key} not found.`;
}

console.log(translate("hello", "en", languageData)); // Output: Hello
console.log(translate("hello", "es", languageData)); // Output: Hola
console.log(translate("welcome", "fr", languageData)); // Output: Bienvenue sur notre site web !
console.log(translate("missingKey", "de", languageData)); // Output: Translation for missingKey in de not found.

முடிவுரை

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