தொழிற்சங்கங்கள் மற்றும் குறுகுதல்

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

யூனியன் வகைகள்

ஒரு யூனியன் வகையானது, பல்வேறு வகைகளின் மதிப்புகளை ஏற்க மாறியை அனுமதிக்கிறது. இது செங்குத்து பட்டை (|) குறியீட்டைப் பயன்படுத்தி வெளிப்படுத்தப்படுகிறது:

let result: number | string;
result = 42; // Valid
result = 'Error 404'; // Valid

இருப்பினும், தொழிற்சங்க வகையுடன் பணிபுரியும் போது, ​​ஒரே ஒரு வகையைச் சேர்ந்த முறைகளை நேரடியாக அழைக்க முடியாது (உதாரணமாக, மாறி number ஆக இருந்தால் .toUpperCase() ஐ அழைக்க முடியாது). நாம் முதலில் வகை "குறுகிய" வேண்டும்.

வகை குறுகுதல்

Type Narrowing என்பது இயக்க நேரத்தில் ஒரு மாறிக்கான மிகவும் குறிப்பிட்ட வகையைக் கண்டறிய, கட்டுப்பாட்டு ஓட்ட அமைப்புகளை (if அல்லது switch போன்றவை) டைப்ஸ்கிரிப்ட் பகுப்பாய்வு செய்யும் செயல்முறையாகும்.

குறுகலைச் செய்ய பல வழிகள் உள்ளன:

1. typeof ஆபரேட்டர்

பழமையான வகைகளை வேறுபடுத்துவதற்கு ஏற்றது:

function printLength(value: string | number) {
  if (typeof value === 'string') {
    // TypeScript knows 'value' is a string here
    console.log(value.length);
  } else {
    // TypeScript knows 'value' is a number here
    console.log(value.toFixed(2));
  }
}

2. in ஆபரேட்டர்

ஒரு பொருளில் ஒரு குறிப்பிட்ட சொத்து உள்ளதா என்பதைச் சரிபார்க்கப் பயன்படுகிறது:

interface Fish {
  swim: () => void;
}
interface Bird {
  fly: () => void;
}

function move(animal: Fish | Bird) {
  if ('swim' in animal) {
    animal.swim(); // Narrowing to Fish
  } else {
    animal.fly(); // Narrowing to Bird
  }
}

பாரபட்சமான தொழிற்சங்கங்கள்

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

interface SuccessResponse {
  status: 'success'; // Literal discriminator
  data: string;
}

interface ErrorResponse {
  status: 'error'; // Literal discriminator
  errorMessage: string;
}

type ApiResponse = SuccessResponse | ErrorResponse;

function handleResponse(response: ApiResponse) {
  if (response.status === 'success') {
    console.log('Data received:', response.data);
  } else {
    console.error('An error occurred:', response.errorMessage);
  }
}

நீங்களே முயற்சி செய்து பாருங்கள்

பயிற்சி 1: யூனியன் வகைகள்

பயிற்சி 2: அடிப்படை வகை குறுக்குதல்

பயிற்சி 3: 'இன்' உடன் சுருக்குதல்

பயிற்சி 4: பாரபட்சமான யூனியன் வடிவம்