டைப்ஸ்கிரிப்ட் எக்ஸாக்ட் வகைகள்: வலுவான குறியீட்டிற்கான கடுமையான ஆப்ஜெக்ட் வடிவ பொருத்தம்

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

டைப்ஸ்கிரிப்ட்டின் கட்டமைப்பு தட்டச்சு முறையைப் புரிந்துகொள்ளுதல்

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

உதாரணமாக:

interface Point {
  x: number;
  y: number;
}

const myPoint = { x: 10, y: 20, z: 30 };

function printPoint(point: Point) {
  console.log(`X: ${point.x}, Y: ${point.y}`);
}

printPoint(myPoint); // myPoint-ல் 'z' பண்பு இருந்தாலும் இது சரியாக வேலை செய்யும்

இந்த சூழ்நிலையில், டைப்ஸ்கிரிப்ட் `myPoint`-ஐ `printPoint`-க்கு அனுப்ப அனுமதிக்கிறது, ஏனெனில் அது கூடுதல் `z` பண்பைக் கொண்டிருந்தாலும், தேவையான `x` மற்றும் `y` பண்புகளைக் கொண்டுள்ளது. இந்த நெகிழ்வுத்தன்மை வசதியாக இருந்தாலும், நீங்கள் தற்செயலாக எதிர்பாராத பண்புகளுடன் ஆப்ஜெக்ட்களை அனுப்பினால், அது நுட்பமான பிழைகளுக்கு வழிவகுக்கும்.

அதிகப்படியான பண்புகளால் ஏற்படும் சிக்கல்

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

interface Config {
  apiUrl: string;
  timeout: number;
}

function setup(config: Config) {
  console.log(`API URL: ${config.apiUrl}`);
  console.log(`Timeout: ${config.timeout}`);
}

const myConfig = { apiUrl: "https://api.example.com", timeout: 5000, typo: true };

setup(myConfig); // டைப்ஸ்கிரிப்ட் இங்கு புகார் செய்யாது!

console.log(myConfig.typo); //prints true. கூடுதல் பண்பு அமைதியாக உள்ளது

இந்த எடுத்துக்காட்டில், `myConfig`-க்கு `typo` என்ற கூடுதல் பண்பு உள்ளது. `myConfig` இன்னும் `Config` இடைமுகத்தை திருப்திப்படுத்துவதால் டைப்ஸ்கிரிப்ட் ஒரு பிழையை எழுப்பாது. இருப்பினும், எழுத்துப்பிழை ஒருபோதும் பிடிக்கப்படவில்லை, மற்றும் எழுத்துப்பிழை `typoo` என்று இருக்க வேண்டும் என நினைத்திருந்தால் பயன்பாடு எதிர்பார்த்தபடி செயல்படாது. இந்த அற்பமானதாகத் தோன்றும் சிக்கல்கள் சிக்கலான பயன்பாடுகளை பிழைத்திருத்தம் செய்யும்போது பெரிய தலைவலியாக வளரக்கூடும். ஆப்ஜெக்ட்களுக்குள் உள்ளமைக்கப்பட்ட ஆப்ஜெக்ட்களைக் கையாளும்போது காணாமல் போன அல்லது தவறாக எழுதப்பட்ட பண்பைக் கண்டறிவது மிகவும் கடினமாக இருக்கும்.

டைப்ஸ்கிரிப்ட்டில் எக்ஸாக்ட் வகைகளைச் செயல்படுத்துவதற்கான அணுகுமுறைகள்

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

1. Omit உடன் டைப் அசெர்ஷன்களைப் பயன்படுத்துதல்

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

interface Point {
  x: number;
  y: number;
}

const myPoint = { x: 10, y: 20, z: 30 };

// Point-இன் பண்புகளை மட்டும் கொண்ட ஒரு வகையை உருவாக்கவும்
const exactPoint: Point = myPoint as Omit & Point;

// பிழை: Type '{ x: number; y: number; z: number; }' is not assignable to type 'Point'.
// Object literal may only specify known properties, and 'z' does not exist in type 'Point'.

function printPoint(point: Point) {
  console.log(`X: ${point.x}, Y: ${point.y}`);
}


//சரிசெய்தல்
const myPointCorrect = { x: 10, y: 20 };
const exactPointCorrect: Point = myPointCorrect as Omit & Point;
printPoint(exactPointCorrect);

இந்த அணுகுமுறை, `myPoint`-ல் `Point` இடைமுகத்தில் வரையறுக்கப்படாத பண்புகள் இருந்தால் ஒரு பிழையைத் தூண்டும்.

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

2. ஆப்ஜெக்ட்களை உருவாக்க ஒரு ஃபங்ஷனைப் பயன்படுத்துதல்

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

interface Config {
  apiUrl: string;
  timeout: number;
}

function createConfig(config: Config): Config {
  return {
    apiUrl: config.apiUrl,
    timeout: config.timeout,
  };
}

const myConfig = createConfig({ apiUrl: "https://api.example.com", timeout: 5000 });

//இது கம்பைல் ஆகாது:
//const myConfigError = createConfig({ apiUrl: "https://api.example.com", timeout: 5000, typo: true });
//Argument of type '{ apiUrl: string; timeout: number; typo: true; }' is not assignable to parameter of type 'Config'.
// Object literal may only specify known properties, and 'typo' does not exist in type 'Config'.

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

3. டைப் கார்டுகளைப் பயன்படுத்துதல்

டைப் கார்டுகள் என்பது ஒரு குறிப்பிட்ட வரம்பிற்குள் ஒரு மாறியின் வகையைச் சுருக்கும் ஃபங்ஷன்கள். அவை நேரடியாக அதிகப்படியான பண்புகளைத் தடுக்கவில்லை என்றாலும், அவற்றை வெளிப்படையாகச் சரிபார்த்து பொருத்தமான நடவடிக்கை எடுக்க அவை உங்களுக்கு உதவக்கூடும்.

interface User {
  id: number;
  name: string;
}

function isUser(obj: any): obj is User {
  return (
    typeof obj === 'object' &&
    obj !== null &&
    'id' in obj && typeof obj.id === 'number' &&
    'name' in obj && typeof obj.name === 'string' &&
    Object.keys(obj).length === 2 //கீஸ்களின் எண்ணிக்கையை சரிபார்க்கவும். குறிப்பு: இது User-இன் சரியான கீ எண்ணிக்கையைப் பொறுத்தது மற்றும் பலவீனமானது.
  );
}

const potentialUser1 = { id: 123, name: "Alice" };
const potentialUser2 = { id: 456, name: "Bob", extra: true };

if (isUser(potentialUser1)) {
  console.log("Valid User:", potentialUser1.name);
} else {
  console.log("Invalid User");
}

if (isUser(potentialUser2)) {
  console.log("Valid User:", potentialUser2.name); //இங்கு வராது
} else {
  console.log("Invalid User");
}

இந்த எடுத்துக்காட்டில், `isUser` டைப் கார்டு தேவையான பண்புகள் இருப்பதோடு மட்டுமல்லாமல், அவற்றின் வகைகள் மற்றும் *சரியான* பண்புகளின் எண்ணிக்கையையும் சரிபார்க்கிறது. இந்த அணுகுமுறை மிகவும் வெளிப்படையானது மற்றும் தவறான ஆப்ஜெக்ட்களை நீங்கள் மென்மையாகக் கையாள அனுமதிக்கிறது. இருப்பினும், பண்புகளின் எண்ணிக்கை சரிபார்ப்பு பலவீனமானது. `User`-க்கு பண்புகள் சேர்க்கப்படும்போதோ அல்லது நீக்கப்படும்போதோ, சரிபார்ப்பு புதுப்பிக்கப்பட வேண்டும்.

4. Readonly மற்றும் as const ஐப் பயன்படுத்துதல்

`Readonly` ஏற்கனவே உள்ள பண்புகளை மாற்றுவதைத் தடுக்கிறது, மற்றும் `as const` ஒரு ரீட்-ஒன்லி ட்யூபிள் அல்லது ஆப்ஜெக்ட்டை உருவாக்குகிறது, அங்கு அனைத்து பண்புகளும் ஆழமாக ரீட்-ஒன்லி மற்றும் லிட்டரல் வகைகளைக் கொண்டுள்ளன, அவை மற்ற முறைகளுடன் இணைக்கப்படும்போது கடுமையான வரையறை மற்றும் வகை சரிபார்ப்பை உருவாக்கப் பயன்படுத்தப்படலாம். இருப்பினும், இரண்டுமே தனியாக அதிகப்படியான பண்புகளைத் தடுக்காது.

interface Options {
  width: number;
  height: number;
}

//Readonly வகையை உருவாக்கவும்
type ReadonlyOptions = Readonly;

const options: ReadonlyOptions = { width: 100, height: 200 };

//options.width = 300; //பிழை: Cannot assign to 'width' because it is a read-only property.

//as const ஐப் பயன்படுத்துதல்
const config = { api_url: "https://example.com", timeout: 3000 } as const;

//config.timeout = 5000; //பிழை: Cannot assign to 'timeout' because it is a read-only property.

//இருப்பினும், அதிகப்படியான பண்புகள் இன்னும் அனுமதிக்கப்படுகின்றன:
const invalidOptions: ReadonlyOptions = { width: 100, height: 200, depth: 300 }; //பிழை இல்லை. இன்னும் அதிகப்படியான பண்புகளை அனுமதிக்கிறது.


interface StrictOptions {
  readonly width: number;
  readonly height: number;
}

//இது இப்போது பிழையைக் காட்டும்:
//const invalidStrictOptions: StrictOptions = { width: 100, height: 200, depth: 300 };
//Type '{ width: number; height: number; depth: number; }' is not assignable to type 'StrictOptions'.
//  Object literal may only specify known properties, and 'depth' does not exist in type 'StrictOptions'.

இது மாற்ற முடியாத தன்மையை மேம்படுத்துகிறது, ஆனால் மாற்றத்தைத் தடுக்கிறது, கூடுதல் பண்புகள் இருப்பதை அல்ல. `Omit` அல்லது ஃபங்ஷன் அணுகுமுறையுடன் இணைந்தால், இது மிகவும் பயனுள்ளதாக இருக்கும்.

5. லைப்ரரிகளைப் பயன்படுத்துதல் (உதாரணமாக, Zod, io-ts)

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

Zod உடன் உதாரணம்:

import { z } from 'zod';

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
});

type User = z.infer;

const validUser = { id: 1, name: "John" };
const invalidUser = { id: 2, name: "Jane", extra: true };

const parsedValidUser = UserSchema.parse(validUser);
console.log("Parsed Valid User:", parsedValidUser);

try {
  const parsedInvalidUser = UserSchema.parse(invalidUser);
  console.log("Parsed Invalid User:", parsedInvalidUser); // இது அடையப்படாது
} catch (error) {
  console.error("Validation Error:", error.errors);
}

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

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

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

• சரியான நுட்பத்தைத் தேர்வுசெய்க: சிறந்த அணுகுமுறை உங்கள் குறிப்பிட்ட தேவைகள் மற்றும் திட்டத் தேவைகளைப் பொறுத்தது. எளிய நிகழ்வுகளுக்கு, `Omit` உடன் டைப் அசெர்ஷன்கள் அல்லது ஃபேக்டரி ஃபங்ஷன்கள் போதுமானதாக இருக்கலாம். மேலும் சிக்கலான சூழ்நிலைகளுக்கு அல்லது ரன்டைம் சரிபார்ப்பு தேவைப்படும்போது, Zod அல்லது io-ts போன்ற லைப்ரரிகளைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• நிலையாக இருங்கள்: ஒரு சீரான வகை பாதுகாப்பை பராமரிக்க உங்கள் குறியீட்டுத் தளம் முழுவதும் நீங்கள் தேர்ந்தெடுத்த அணுகுமுறையை சீராகப் பயன்படுத்துங்கள்.
• உங்கள் வகைகளை ஆவணப்படுத்துங்கள்: உங்கள் தரவின் எதிர்பார்க்கப்படும் வடிவத்தை மற்ற டெவலப்பர்களுக்குத் தெரிவிக்க உங்கள் இடைமுகங்கள் மற்றும் வகைகளை தெளிவாக ஆவணப்படுத்துங்கள்.
• உங்கள் குறியீட்டைச் சோதிக்கவும்: உங்கள் வகை கட்டுப்பாடுகள் எதிர்பார்த்தபடி செயல்படுகின்றனவா என்பதையும், உங்கள் குறியீடு தவறான தரவை மென்மையாகக் கையாளுகிறதா என்பதையும் சரிபார்க்க யூனிட் சோதனைகளை எழுதுங்கள்.
• சாதக பாதகங்களைக் கருத்தில் கொள்ளுங்கள்: கடுமையான ஆப்ஜெக்ட் வடிவ பொருத்தத்தைச் செயல்படுத்துவது உங்கள் குறியீட்டை மேலும் வலுவானதாக மாற்றும், ஆனால் இது மேம்பாட்டு நேரத்தையும் அதிகரிக்கக்கூடும். நன்மைகளை செலவுகளுடன் ஒப்பிட்டு, உங்கள் திட்டத்திற்கு மிகவும் பொருத்தமான அணுகுமுறையைத் தேர்வுசெய்க.
• படிப்படியான தழுவல்: நீங்கள் ஒரு பெரிய தற்போதுள்ள குறியீட்டுத் தளத்தில் பணிபுரிகிறீர்கள் என்றால், இந்த நுட்பங்களை படிப்படியாகத் தழுவி, உங்கள் பயன்பாட்டின் மிக முக்கியமான பகுதிகளிலிருந்து தொடங்கவும்.
• ஆப்ஜெக்ட் வடிவங்களை வரையறுக்கும்போது டைப் அலியாஸ்களை விட இடைமுகங்களுக்கு முன்னுரிமை கொடுங்கள்: இடைமுகங்கள் பொதுவாக விரும்பப்படுகின்றன, ஏனெனில் அவை அறிவிப்பு இணைப்பை ஆதரிக்கின்றன, இது வெவ்வேறு கோப்புகளில் வகைகளை நீட்டிக்க பயனுள்ளதாக இருக்கும்.

நிஜ உலக உதாரணங்கள்

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

• API கோரிக்கை பேலோடுகள்: ஒரு API-க்கு தரவை அனுப்பும்போது, பேலோட் எதிர்பார்க்கப்படும் ஸ்கீமாவுடன் இணங்குவதை உறுதி செய்வது முக்கியம். எக்ஸாக்ட் வகைகளைச் செயல்படுத்துவது எதிர்பாராத பண்புகளை அனுப்புவதால் ஏற்படும் பிழைகளைத் தடுக்கலாம். உதாரணமாக, பல கட்டணச் செயலாக்க API-கள் எதிர்பாராத தரவுகளுக்கு மிகவும் உணர்திறன் கொண்டவை.
• கட்டமைப்பு கோப்புகள்: கட்டமைப்பு கோப்புகள் பெரும்பாலும் அதிக எண்ணிக்கையிலான பண்புகளைக் கொண்டுள்ளன, மேலும் எழுத்துப்பிழைகள் பொதுவானவை. எக்ஸாக்ட் வகைகளைப் பயன்படுத்துவது இந்த எழுத்துப்பிழைகளை முன்கூட்டியே பிடிக்க உதவும். நீங்கள் ஒரு கிளவுட் வரிசைப்படுத்தலில் சர்வர் இருப்பிடங்களை அமைக்கும்போது, ஒரு இருப்பிட அமைப்பில் ஒரு எழுத்துப்பிழை (எ.கா. eu-west-1 vs. eu-wet-1) முன்கூட்டியே பிடிக்கப்படாவிட்டால், பிழைத்திருத்தம் செய்வது மிகவும் கடினமாகிவிடும்.
• தரவு மாற்றும் பைப்லைன்கள்: தரவை ஒரு வடிவத்திலிருந்து மற்றொரு வடிவத்திற்கு மாற்றும்போது, வெளியீட்டுத் தரவு எதிர்பார்க்கப்படும் ஸ்கீமாவுடன் இணங்குவதை உறுதி செய்வது முக்கியம்.
• செய்தி வரிசைகள்: ஒரு செய்தி வரிசை மூலம் செய்திகளை அனுப்பும்போது, செய்தி பேலோட் செல்லுபடியாகும் மற்றும் சரியான பண்புகளைக் கொண்டிருப்பதை உறுதி செய்வது முக்கியம்.

உதாரணம்: பன்மொழி ஆதரவு (i18n) கட்டமைப்பு

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

interface Translation {
  greeting: string;
  farewell: string;
}

interface I18nConfig {
  locale: string;
  translations: Translation;
}

const englishConfig: I18nConfig = {
  locale: "en-US",
  translations: {
    greeting: "Hello",
    farewell: "Goodbye"
  }
};


//இது ஒரு சிக்கலாக இருக்கும், ஏனெனில் ஒரு கூடுதல் பண்பு உள்ளது, அமைதியாக ஒரு பிழையை அறிமுகப்படுத்துகிறது.
const spanishConfig: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós",
    typo: "unintentional translation"
  }
};

//தீர்வு: Omit ஐப் பயன்படுத்துதல்
const spanishConfigCorrect: I18nConfig = {
  locale: "es-ES",
  translations: {
    greeting: "Hola",
    farewell: "Adiós"
  } as Omit & Translation
};

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

முடிவுரை

டைப்ஸ்கிரிப்ட்டில் உள்ளமைக்கப்பட்ட "எக்ஸாக்ட் வகைகள்" இல்லை என்றாலும், டைப்ஸ்கிரிப்ட் அம்சங்கள் மற்றும் `Omit` உடன் டைப் அசெர்ஷன்கள், ஃபேக்டரி ஃபங்ஷன்கள், டைப் கார்டுகள், `Readonly`, `as const` மற்றும் Zod மற்றும் io-ts போன்ற வெளிப்புற லைப்ரரிகளின் கலவையைப் பயன்படுத்தி இதே போன்ற முடிவுகளை நீங்கள் அடையலாம். கடுமையான ஆப்ஜெக்ட் வடிவ பொருத்தத்தைச் செயல்படுத்துவதன் மூலம், உங்கள் குறியீட்டின் வலிமையை மேம்படுத்தலாம், பொதுவான பிழைகளைத் தடுக்கலாம் மற்றும் உங்கள் பயன்பாடுகளை மேலும் நம்பகமானதாக மாற்றலாம். உங்கள் தேவைகளுக்கு மிகவும் பொருத்தமான அணுகுமுறையைத் தேர்வுசெய்து, அதை உங்கள் குறியீட்டுத் தளம் முழுவதும் சீராகப் பயன்படுத்துவதை நினைவில் கொள்ளுங்கள். இந்த அணுகுமுறைகளை கவனமாகக் கருத்தில் கொள்வதன் மூலம், உங்கள் பயன்பாட்டின் வகைகள் மீது அதிக கட்டுப்பாட்டை எடுத்து நீண்ட கால பராமரிப்பை அதிகரிக்கலாம்.