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

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

லிட்டரல் டைப்ஸ் என்றால் என்ன?

string, number, அல்லது boolean போன்ற பாரம்பரிய டைப்ஸ்களைப் போலன்றி, லிட்டரல் டைப்ஸ் மதிப்புகளின் பரந்த வகையைக் குறிப்பதில்லை. அதற்கு பதிலாக, அவை குறிப்பிட்ட, நிலையான மதிப்புகளைக் குறிக்கின்றன. டைப்ஸ்கிரிப்ட் மூன்று வகையான லிட்டரல் டைப்ஸ்களை ஆதரிக்கிறது:

• ஸ்டிரிங் லிட்டரல் டைப்ஸ் (String Literal Types): குறிப்பிட்ட ஸ்டிரிங் மதிப்புகளைக் குறிக்கின்றன.
• எண் லிட்டரல் டைப்ஸ் (Number Literal Types): குறிப்பிட்ட எண் மதிப்புகளைக் குறிக்கின்றன.
• பூலியன் லிட்டரல் டைப்ஸ் (Boolean Literal Types): true அல்லது false என்ற குறிப்பிட்ட மதிப்புகளைக் குறிக்கின்றன.

லிட்டரல் டைப்ஸ்களைப் பயன்படுத்துவதன் மூலம், உங்கள் தரவுகளின் உண்மையான கட்டுப்பாடுகளைப் பிரதிபலிக்கும் மிகவும் துல்லியமான டைப் வரையறைகளை உருவாக்க முடியும், இது மேலும் வலுவான மற்றும் பராமரிக்க எளிதான குறியீட்டிற்கு வழிவகுக்கிறது.

ஸ்டிரிங் லிட்டரல் டைப்ஸ் (String Literal Types)

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

அடிப்படை சிண்டாக்ஸ் (Basic Syntax)

ஒரு ஸ்டிரிங் லிட்டரல் டைப்பை வரையறுப்பதற்கான சிண்டாக்ஸ் நேரடியானது:

type AllowedValues = "value1" | "value2" | "value3";

இது AllowedValues என்ற ஒரு டைப்பை வரையறுக்கிறது, இது "value1", "value2", அல்லது "value3" என்ற ஸ்டிரிங்குகளை மட்டுமே வைத்திருக்க முடியும்.

நடைமுறை எடுத்துக்காட்டுகள்

1. ஒரு வண்ணத் தட்டுகளை வரையறுத்தல் (Defining a Color Palette):

நீங்கள் ஒரு UI நூலகத்தை உருவாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள், பயனர்கள் முன்னரே வரையறுக்கப்பட்ட தட்டுகளிலிருந்து மட்டுமே வண்ணங்களைக் குறிப்பிட முடியும் என்பதை உறுதிப்படுத்த விரும்புகிறீர்கள்:

type Color = "red" | "green" | "blue" | "yellow";

function paintElement(element: HTMLElement, color: Color) {
  element.style.backgroundColor = color;
}

paintElement(document.getElementById("myElement")!, "red"); // செல்லுபடியாகும்
paintElement(document.getElementById("myElement")!, "purple"); // பிழை: '"purple"' என்ற வகையின் ஆர்கியூமென்ட் 'Color' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

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

2. API எண்ட்பாயிண்ட்களை வரையறுத்தல் (Defining API Endpoints):

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

type APIEndpoint = "/users" | "/posts" | "/comments";

function fetchData(endpoint: APIEndpoint) {
  // ... குறிப்பிட்ட எண்ட்பாயிண்டிலிருந்து தரவைப் பெறுவதற்கான செயலாக்கம்
  console.log(`Fetching data from ${endpoint}`);
}

fetchData("/users"); // செல்லுபடியாகும்
fetchData("/products"); // பிழை: '"/products"' என்ற வகையின் ஆர்கியூமென்ட் 'APIEndpoint' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

இந்த எடுத்துக்காட்டு, fetchData ஃபங்ஷன் செல்லுபடியாகும் API எண்ட்பாயிண்ட்களுடன் மட்டுமே அழைக்கப்படுவதை உறுதிசெய்கிறது, இது எழுத்துப்பிழைகள் அல்லது தவறான எண்ட்பாயிண்ட் பெயர்களால் ஏற்படும் பிழைகளின் அபாயத்தைக் குறைக்கிறது.

3. வெவ்வேறு மொழிகளைக் கையாளுதல் (Internationalization - i18n):

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

type Language = "en" | "es" | "fr" | "de" | "zh";

function translate(text: string, language: Language): string {
  // ... குறிப்பிட்ட மொழிக்கு உரையை மொழிபெயர்ப்பதற்கான செயலாக்கம்
  console.log(`Translating '${text}' to ${language}`);
  return "Translated text"; // Placeholder
}

translate("Hello", "en"); // செல்லுபடியாகும்
translate("Hello", "ja"); // பிழை: '"ja"' என்ற வகையின் ஆர்கியூமென்ட் 'Language' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

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

எண் லிட்டரல் டைப்ஸ் (Number Literal Types)

எண் லிட்டரல் டைப்ஸ் ஒரு மாறி அல்லது புரோப்பர்ட்டி ஒரு குறிப்பிட்ட எண் மதிப்பை மட்டுமே வைத்திருக்க முடியும் என்பதை குறிப்பிட உங்களை அனுமதிக்கிறது.

அடிப்படை சிண்டாக்ஸ் (Basic Syntax)

ஒரு எண் லிட்டரல் டைப்பை வரையறுப்பதற்கான சிண்டாக்ஸ் ஸ்டிரிங் லிட்டரல் டைப்ஸ்களைப் போன்றது:

type StatusCode = 200 | 404 | 500;

இது StatusCode என்ற ஒரு டைப்பை வரையறுக்கிறது, இது 200, 404, அல்லது 500 எண்களை மட்டுமே வைத்திருக்க முடியும்.

நடைமுறை எடுத்துக்காட்டுகள்

1. HTTP ஸ்டேட்டஸ் கோட்களை வரையறுத்தல்:

HTTP ஸ்டேட்டஸ் கோட்களைக் குறிக்க நீங்கள் எண் லிட்டரல் டைப்ஸ்களைப் பயன்படுத்தலாம், உங்கள் பயன்பாட்டில் செல்லுபடியாகும் கோட்கள் மட்டுமே பயன்படுத்தப்படுவதை உறுதி செய்யலாம்:

type HTTPStatus = 200 | 400 | 401 | 403 | 404 | 500;

function handleResponse(status: HTTPStatus) {
  switch (status) {
    case 200:
      console.log("Success!");
      break;
    case 400:
      console.log("Bad Request");
      break;
    // ... மற்ற நிலைகள்
    default:
      console.log("Unknown Status");
  }
}

handleResponse(200); // செல்லுபடியாகும்
handleResponse(600); // பிழை: '600' என்ற வகையின் ஆர்கியூமென்ட் 'HTTPStatus' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

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

2. நிலையான விருப்பங்களைக் குறித்தல்:

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

type RetryAttempts = 1 | 3 | 5;

interface Config {
  retryAttempts: RetryAttempts;
}

const config1: Config = { retryAttempts: 3 }; // செல்லுபடியாகும்
const config2: Config = { retryAttempts: 7 }; // பிழை: '{ retryAttempts: 7; }' என்ற டைப் 'Config' என்ற டைப்பிற்கு ஒதுக்க முடியாதது.

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

பூலியன் லிட்டரல் டைப்ஸ் (Boolean Literal Types)

பூலியன் லிட்டரல் டைப்ஸ் true அல்லது false என்ற குறிப்பிட்ட மதிப்புகளைக் குறிக்கின்றன. அவை ஸ்டிரிங் அல்லது எண் லிட்டரல் டைப்ஸ்களை விட குறைவாகப் பயன்படுவதாகத் தோன்றினாலும், குறிப்பிட்ட சூழ்நிலைகளில் அவை பயனுள்ளதாக இருக்கும்.

அடிப்படை சிண்டாக்ஸ் (Basic Syntax)

ஒரு பூலியன் லிட்டரல் டைப்பை வரையறுப்பதற்கான சிண்டாக்ஸ்:

type IsEnabled = true | false;

இருப்பினும், நேரடியாக true | false பயன்படுத்துவது தேவையற்றது, ஏனெனில் இது boolean டைப்பிற்குச் சமமானது. பூலியன் லிட்டரல் டைப்ஸ் மற்ற டைப்ஸ்களுடன் இணைக்கப்படும்போது அல்லது நிபந்தனை டைப்ஸ்களில் மிகவும் பயனுள்ளதாக இருக்கும்.

நடைமுறை எடுத்துக்காட்டுகள்

1. உள்ளமைவுடன் கூடிய நிபந்தனை தர்க்கம்:

ஒரு உள்ளமைவுக் கொடியின் அடிப்படையில் ஒரு ஃபங்ஷனின் நடத்தையைக் கட்டுப்படுத்த நீங்கள் பூலியன் லிட்டரல் டைப்ஸ்களைப் பயன்படுத்தலாம்:

interface FeatureFlags {
  darkMode: boolean;
  newUserFlow: boolean;
}

function initializeApp(flags: FeatureFlags) {
  if (flags.darkMode) {
    // டார்க் மோடை இயக்கு
    console.log("Enabling dark mode...");
  } else {
    // லைட் மோடைப் பயன்படுத்து
    console.log("Using light mode...");
  }

  if (flags.newUserFlow) {
    // புதிய பயனர் ஓட்டத்தை இயக்கு
    console.log("Enabling new user flow...");
  } else {
    // பழைய பயனர் ஓட்டத்தைப் பயன்படுத்து
    console.log("Using old user flow...");
  }
}

initializeApp({ darkMode: true, newUserFlow: false });

இந்த எடுத்துக்காட்டு நிலையான boolean டைப்பைப் பயன்படுத்தினாலும், நீங்கள் இதை நிபந்தனை டைப்ஸ்களுடன் (பின்னர் விளக்கப்பட்டுள்ளது) இணைத்து மிகவும் சிக்கலான நடத்தையை உருவாக்கலாம்.

2. பிரித்தறியப்பட்ட யூனியன்கள் (Discriminated Unions):

பூலியன் லிட்டரல் டைப்ஸ்களை யூனியன் டைப்ஸ்களில் பிரிப்பான்களாகப் பயன்படுத்தலாம். பின்வரும் எடுத்துக்காட்டைக் கவனியுங்கள்:

interface SuccessResult {
  success: true;
  data: any;
}

interface ErrorResult {
  success: false;
  error: string;
}

type Result = SuccessResult | ErrorResult;

function processResult(result: Result) {
  if (result.success) {
    console.log("Success:", result.data);
  } else {
    console.error("Error:", result.error);
  }
}

processResult({ success: true, data: { name: "John" } });
processResult({ success: false, error: "Failed to fetch data" });

இங்கே, success புரோப்பர்ட்டி, ஒரு பூலியன் லிட்டரல் டைப், ஒரு பிரிப்பானாகச் செயல்படுகிறது, இது if கூற்றிற்குள் result-இன் டைப்பை டைப்ஸ்கிரிப்ட் சுருக்க அனுமதிக்கிறது.

லிட்டரல் டைப்ஸ்களை யூனியன் டைப்ஸ்களுடன் இணைத்தல்

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

நடைமுறை எடுத்துக்காட்டுகள்

1. ஒரு ஸ்டேட்டஸ் டைப்பை வரையறுத்தல்:

type Status = "pending" | "in progress" | "completed" | "failed";

interface Task {
  id: number;
  description: string;
  status: Status;
}

const task1: Task = { id: 1, description: "Implement login", status: "in progress" }; // செல்லுபடியாகும்
const task2: Task = { id: 2, description: "Implement logout", status: "done" };       // பிழை: '{ id: number; description: string; status: string; }' என்ற டைப் 'Task' என்ற டைப்பிற்கு ஒதுக்க முடியாதது.

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

2. ஒரு சாதன வகையை வரையறுத்தல்:

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

type DeviceType = "mobile" | "tablet" | "desktop";

function logDeviceType(device: DeviceType) {
  console.log(`Device type: ${device}`);
}

logDeviceType("mobile"); // செல்லுபடியாகும்
logDeviceType("smartwatch"); // பிழை: '"smartwatch"' என்ற வகையின் ஆர்கியூமென்ட் 'DeviceType' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

இந்த எடுத்துக்காட்டு, logDeviceType ஃபங்ஷன் செல்லுபடியாகும் சாதன வகைகளுடன் மட்டுமே அழைக்கப்படுவதை உறுதி செய்கிறது.

டைப் அலைஸஸ் உடன் லிட்டரல் டைப்ஸ் (Literal Types with Type Aliases)

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

நடைமுறை எடுத்துக்காட்டுகள்

1. நாணயக் குறியீடு வகையை வரையறுத்தல்:

type CurrencyCode = "USD" | "EUR" | "GBP" | "JPY";

function formatCurrency(amount: number, currency: CurrencyCode): string {
  // ... நாணயக் குறியீட்டின் அடிப்படையில் தொகையை வடிவமைப்பதற்கான செயலாக்கம்
  console.log(`Formatting ${amount} in ${currency}`);
  return "Formatted amount"; // Placeholder
}

formatCurrency(100, "USD"); // செல்லுபடியாகும்
formatCurrency(200, "CAD"); // பிழை: '"CAD"' என்ற வகையின் ஆர்கியூமென்ட் 'CurrencyCode' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

இந்த எடுத்துக்காட்டு, நாணயக் குறியீடுகளின் ஒரு தொகுப்பிற்காக CurrencyCode என்ற டைப் அலைஸை வரையறுக்கிறது, இது formatCurrency ஃபங்ஷனின் வாசிப்புத் திறனை மேம்படுத்துகிறது.

2. வாரத்தின் நாள் வகையை வரையறுத்தல்:

type DayOfWeek = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday";

function isWeekend(day: DayOfWeek): boolean {
  return day === "Saturday" || day === "Sunday";
}

console.log(isWeekend("Monday"));   // false
console.log(isWeekend("Saturday")); // true
console.log(isWeekend("Funday"));   // பிழை: '"Funday"' என்ற வகையின் ஆர்கியூமென்ட் 'DayOfWeek' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

லிட்டரல் இன்ஃபரன்ஸ் (Literal Inference)

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

நடைமுறை எடுத்துக்காட்டுகள்

1. ஸ்டிரிங் லிட்டரல் டைப்ஸ்களை ஊகித்தல்:

const apiKey = "your-api-key"; // டைப்ஸ்கிரிப்ட் apiKey-இன் டைப்பை "your-api-key" என ஊகிக்கிறது

function validateApiKey(key: "your-api-key") {
  return key === "your-api-key";
}

console.log(validateApiKey(apiKey)); // true

const anotherKey = "invalid-key";
console.log(validateApiKey(anotherKey)); // பிழை: 'string' என்ற வகையின் ஆர்கியூமென்ட் '"your-api-key"' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

இந்த எடுத்துக்காட்டில், டைப்ஸ்கிரிப்ட் apiKey-இன் டைப்பை ஸ்டிரிங் லிட்டரல் டைப் "your-api-key" என ஊகிக்கிறது. இருப்பினும், ஒரு மாறிக்கு நிலையற்ற மதிப்பை ஒதுக்கினால், டைப்ஸ்கிரிப்ட் பொதுவாக பரந்த string டைப்பை ஊகிக்கும்.

2. எண் லிட்டரல் டைப்ஸ்களை ஊகித்தல்:

const port = 8080; // டைப்ஸ்கிரிப்ட் port-இன் டைப்பை 8080 என ஊகிக்கிறது

function startServer(portNumber: 8080) {
  console.log(`Starting server on port ${portNumber}`);
}

startServer(port); // செல்லுபடியாகும்

const anotherPort = 3000;
startServer(anotherPort); // பிழை: 'number' என்ற வகையின் ஆர்கியூமென்ட் '8080' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

நிபந்தனை டைப்ஸ்களுடன் லிட்டரல் டைப்ஸ்களைப் பயன்படுத்துதல்

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

அடிப்படை சிண்டாக்ஸ் (Basic Syntax)

ஒரு நிபந்தனை டைப்பிற்கான சிண்டாக்ஸ்:

TypeA extends TypeB ? TypeC : TypeD

இதன் பொருள்: TypeA, TypeB-க்கு ஒதுக்கக்கூடியதாக இருந்தால், இதன் விளைவாக வரும் டைப் TypeC; இல்லையெனில், இதன் விளைவாக வரும் டைப் TypeD.

நடைமுறை எடுத்துக்காட்டுகள்

1. ஸ்டேட்டஸை செய்தியுடன் இணைத்தல்:

type Status = "pending" | "in progress" | "completed" | "failed";

type StatusMessage = T extends "pending"
  ? "Waiting for action"
  : T extends "in progress"
  ? "Currently processing"
  : T extends "completed"
  ? "Task finished successfully"
  : "An error occurred";

function getStatusMessage(status: T): StatusMessage {
  switch (status) {
    case "pending":
      return "Waiting for action" as StatusMessage;
    case "in progress":
      return "Currently processing" as StatusMessage;
    case "completed":
      return "Task finished successfully" as StatusMessage;
    case "failed":
      return "An error occurred" as StatusMessage;
    default:
      throw new Error("Invalid status");
  }
}

console.log(getStatusMessage("pending"));    // Waiting for action
console.log(getStatusMessage("in progress")); // Currently processing
console.log(getStatusMessage("completed"));   // Task finished successfully
console.log(getStatusMessage("failed"));      // An error occurred

இந்த எடுத்துக்காட்டு, நிபந்தனை டைப்ஸ்களைப் பயன்படுத்தி ஒவ்வொரு சாத்தியமான ஸ்டேட்டஸையும் அதனுடன் தொடர்புடைய செய்திக்கு வரைபடமாக்கும் ஒரு StatusMessage டைப்பை வரையறுக்கிறது. getStatusMessage ஃபங்ஷன் இந்த டைப்பைப் பயன்படுத்தி டைப்-பாதுகாப்பான ஸ்டேட்டஸ் செய்திகளை வழங்குகிறது.

2. ஒரு டைப்-பாதுகாப்பான நிகழ்வு கையாளுபவரை உருவாக்குதல்:

type EventType = "click" | "mouseover" | "keydown";

type EventData = T extends "click"
  ? { x: number; y: number; } // கிளிக் நிகழ்வு தரவு
  : T extends "mouseover"
  ? { target: HTMLElement; }   // மவுஸ்ஓவர் நிகழ்வு தரவு
  : { key: string; }             // கீடவுன் நிகழ்வு தரவு

function handleEvent(type: T, data: EventData) {
  console.log(`Handling event type ${type} with data:`, data);
}

handleEvent("click", { x: 10, y: 20 }); // செல்லுபடியாகும்
handleEvent("mouseover", { target: document.getElementById("myElement")! }); // செல்லுபடியாகும்
handleEvent("keydown", { key: "Enter" }); // செல்லுபடியாகும்

handleEvent("click", { key: "Enter" }); // பிழை: '{ key: string; }' என்ற வகையின் ஆர்கியூமென்ட் '{ x: number; y: number; }' என்ற வகையின் பாராமீட்டருக்கு ஒதுக்க முடியாதது.

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

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

உங்கள் டைப்ஸ்கிரிப்ட் திட்டங்களில் லிட்டரல் டைப்ஸ்களை திறம்பட பயன்படுத்த, பின்வரும் சிறந்த நடைமுறைகளைக் கவனியுங்கள்:

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

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

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

முடிவுரை

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