టైప్‌స్క్రిప్ట్ ఎగ్జాక్ట్ టైప్స్: దృఢమైన కోడ్ కోసం కఠినమైన ఆబ్జెక్ట్ షేప్ మ్యాచింగ్

టైప్‌స్క్రిప్ట్, జావాస్క్రిప్ట్ యొక్క సూపర్‌సెట్, వెబ్ డెవలప్‌మెంట్ యొక్క డైనమిక్ ప్రపంచానికి స్టాటిక్ టైపింగ్‌ను తీసుకువస్తుంది. టైప్‌స్క్రిప్ట్ టైప్ సేఫ్టీ మరియు కోడ్ మెయింటెనబిలిటీ పరంగా గణనీయమైన ప్రయోజనాలను అందిస్తున్నప్పటికీ, దాని స్ట్రక్చరల్ టైపింగ్ సిస్టమ్ కొన్నిసార్లు అనూహ్యమైన ప్రవర్తనకు దారితీయవచ్చు. ఇక్కడే "ఎగ్జాక్ట్ టైప్స్" అనే భావన వస్తుంది. టైప్‌స్క్రిప్ట్‌లో "ఎగ్జాక్ట్ టైప్స్" అని స్పష్టంగా పేరు పెట్టబడిన అంతర్నిర్మిత ఫీచర్ లేనప్పటికీ, మనం టైప్‌స్క్రిప్ట్ ఫీచర్లు మరియు టెక్నిక్‌ల కలయిక ద్వారా ఇలాంటి ప్రవర్తనను సాధించవచ్చు. ఈ బ్లాగ్ పోస్ట్ కోడ్ దృఢత్వాన్ని మెరుగుపరచడానికి మరియు సాధారణ లోపాలను నివారించడానికి టైప్‌స్క్రిప్ట్‌లో కఠినమైన ఆబ్జెక్ట్ షేప్ మ్యాచింగ్‌ను ఎలా అమలు చేయాలో వివరిస్తుంది.

టైప్‌స్క్రిప్ట్ యొక్క స్ట్రక్చరల్ టైపింగ్‌ను అర్థం చేసుకోవడం

టైప్‌స్క్రిప్ట్ స్ట్రక్చరల్ టైపింగ్ (డక్ టైపింగ్ అని కూడా పిలుస్తారు)ను ఉపయోగిస్తుంది, అంటే టైప్ అనుకూలత వాటి ప్రకటించబడిన పేర్ల కంటే, టైప్స్ యొక్క సభ్యుల ద్వారా నిర్ణయించబడుతుంది. ఒక ఆబ్జెక్ట్‌లో అదనపు ప్రాపర్టీలు ఉన్నప్పటికీ, ఒక టైప్‌కు అవసరమైన అన్ని ప్రాపర్టీలు ఉంటే, అది ఆ టైప్‌కు అనుకూలమైనదిగా పరిగణించబడుతుంది.

ఉదాహరణకు:

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`కి అదనంగా `z` ప్రాపర్టీ ఉన్నప్పటికీ, దానికి అవసరమైన `x` మరియు `y` ప్రాపర్టీలు ఉన్నందున `printPoint`కి పంపడానికి అనుమతిస్తుంది. ఈ సౌలభ్యం అనుకూలమైనదిగా ఉన్నప్పటికీ, మీరు అనుకోకుండా అనూహ్యమైన ప్రాపర్టీలతో ఆబ్జెక్ట్‌లను పంపితే, అది సూక్ష్మ బగ్‌లకు దారితీయవచ్చు.

అదనపు ప్రాపర్టీలతో సమస్య

స్ట్రక్చరల్ టైపింగ్ యొక్క సరళత కొన్నిసార్లు లోపాలను కప్పిపుచ్చుతుంది. ఒక కాన్ఫిగరేషన్ ఆబ్జెక్ట్‌ను ఆశించే ఫంక్షన్‌ను పరిగణించండి:

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); // 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;

// Error: 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}`);
}


//Fix
const myPointCorrect = { x: 10, y: 20 };
const exactPointCorrect: Point = myPointCorrect as Omit & Point;
printPoint(exactPointCorrect);

`Point` ఇంటర్‌ఫేస్‌లో నిర్వచించబడని ప్రాపర్టీలు `myPoint`లో ఉంటే ఈ పద్ధతి ఎర్రర్ ఇస్తుంది.

వివరణ: `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; //error: 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; //error: 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 వంటి బాహ్య లైబ్రరీల వంటి టైప్‌స్క్రిప్ట్ ఫీచర్లు మరియు టెక్నిక్‌ల కలయికను ఉపయోగించి ఇలాంటి ఫలితాలను సాధించవచ్చు. కఠినమైన ఆబ్జెక్ట్ షేప్ మ్యాచింగ్‌ను అమలు చేయడం ద్వారా, మీరు మీ కోడ్ యొక్క దృఢత్వాన్ని మెరుగుపరచవచ్చు, సాధారణ లోపాలను నివారించవచ్చు మరియు మీ అప్లికేషన్‌లను మరింత విశ్వసనీయంగా చేయవచ్చు. మీ అవసరాలకు ఉత్తమంగా సరిపోయే పద్ధతిని ఎంచుకోవాలని గుర్తుంచుకోండి మరియు దానిని మీ కోడ్‌బేస్ అంతటా స్థిరంగా వర్తింపజేయండి. ఈ పద్ధతులను జాగ్రత్తగా పరిగణించడం ద్వారా, మీరు మీ అప్లికేషన్ యొక్క టైప్స్‌పై ఎక్కువ నియంత్రణను తీసుకోవచ్చు మరియు దీర్ఘకాలిక మెయింటెనబిలిటీని పెంచవచ్చు.