தொகுப்பிகள் எப்படி அறிவாளியாகின்றன: வகை சுருக்கம் மற்றும் கட்டுப்பாட்டுப் பாய்ச்சல் பகுப்பாய்வு குறித்த ஆழமான பார்வை

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

நீங்கள் எப்போதாவது string அல்லது number ஆக இருக்கக்கூடிய ஒரு மாறியுடன் பணிபுரிந்திருக்கிறீர்களா? ஒரு செயல்பாட்டைச் செய்வதற்கு முன் அதன் வகையைச் சரிபார்க்க நீங்கள் பெரும்பாலும் if அறிக்கையை எழுதியிருப்பீர்கள். அந்தத் தொகுதிக்குள், மொழி மாறி ஒரு string என்பதை 'அறிந்தது', சரம் சார்ந்த குறிப்பிட்ட முறைகளைத் திறக்கிறது மற்றும் எடுத்துக்காட்டாக, ஒரு எண்ணில் .toUpperCase() அழைக்க முயற்சிப்பதைத் தடுக்கிறது. ஒரு குறிப்பிட்ட குறியீடு பாதையில் ஒரு வகையின் அந்த அறிவார்ந்த சுத்திகரிப்பு வகை சுருக்குதல் ஆகும்.

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

வகை சுருக்குதல் என்றால் என்ன? ஒரு நடைமுறை அறிமுகம்

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

டைப்ஸ்கிரிப்டைப் பயன்படுத்தி சில பொதுவான எடுத்துக்காட்டுகளைப் பார்ப்போம், அதன் தெளிவான தொடரியலுக்காக, கொள்கைகள் பைதான் (மைப்பி உடன்), கோட்லின் மற்றும் பிற நவீன மொழிகளுக்குப் பொருந்தும்.

பொதுவான சுருக்கும் நுட்பங்கள்

• `typeof` காவலர்கள்: இது மிகவும் உன்னதமான உதாரணம். ஒரு மாறியின் பழமையான வகையை நாங்கள் சரிபார்க்கிறோம்.

  உதாரணமாக:

  function processInput(input: string | number) {
if (typeof input === 'string') {
// இந்தத் தொகுதிக்குள், 'input' ஒரு சரமாக அறியப்படுகிறது.
console.log(input.toUpperCase()); // இது பாதுகாப்பானது!
} else {
// இந்தத் தொகுதிக்குள், 'input' ஒரு எண்ணாக அறியப்படுகிறது.
console.log(input.toFixed(2)); // இதுவும் பாதுகாப்பானது!
}
}

• `instanceof` காவலர்கள்: அவற்றின் கன்ஸ்ட்ரக்டர் செயல்பாடு அல்லது வகுப்பின் அடிப்படையில் பொருள் வகைகளை சுருக்கப் பயன்படுகிறது.

  உதாரணமாக:

  class User { constructor(public name: string) {} }
class Guest { constructor() {} }

function greet(person: User | Guest) {
if (person instanceof User) {
// 'person' வகை பயனருக்குக் குறுகியது.
console.log(`Hello, ${person.name}!`);
} else {
// 'person' வகை விருந்தினருக்குக் குறுகியது.
console.log('Hello, guest!');
}
}

• உண்மைத்தன்மை சோதனைகள்: `null`, `undefined`, `0`, `false` அல்லது வெற்று சரங்களை வடிகட்ட ஒரு பொதுவான முறை.

  உதாரணமாக:

  function printName(name: string | null | undefined) {
if (name) {
// 'name' 'string | null | undefined' இலிருந்து 'string' ஆக சுருக்கப்பட்டுள்ளது.
console.log(name.length);
}
}

• சமத்துவம் மற்றும் சொத்து காவலர்கள்: குறிப்பிட்ட நேரடி மதிப்புகளைச் சரிபார்ப்பது அல்லது ஒரு சொத்தின் இருப்பைச் சரிபார்ப்பது வகைகளையும் சுருக்கலாம், குறிப்பாக வேறுபடுத்தப்பட்ட யூனியன்களுடன்.

  உதாரணமாக (வேறுபடுத்தப்பட்ட யூனியன்):

  interface Circle { kind: 'circle'; radius: number; }
interface Square { kind: 'square'; sideLength: number; }
type Shape = Circle | Square;

function getArea(shape: Shape) {
if (shape.kind === 'circle') {
// 'shape' வட்டமாகக் குறுகியது.
return Math.PI * shape.radius ** 2;
} else {
// 'shape' சதுரமாகக் குறுகியது.
return shape.sideLength ** 2;
}
}

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

மாயாஜாலத்தின் பின்னணியில் உள்ள இயந்திரம்: கட்டுப்பாட்டுப் பாய்ச்சல் பகுப்பாய்வைப் புரிந்துகொள்வது (CFA)

கட்டுப்பாட்டுப் பாய்ச்சல் பகுப்பாய்வு என்பது ஒரு கம்பைலர் அல்லது வகை சரிபார்ப்பவர் ஒரு நிரல் எடுக்கக்கூடிய சாத்தியமான இயக்கப் பாதைகளைப் புரிந்து கொள்ள அனுமதிக்கும் நிலையான பகுப்பாய்வு நுட்பமாகும். இது குறியீட்டை இயக்காது; அது அதன் கட்டமைப்பை பகுப்பாய்வு செய்கிறது. இதற்குப் பயன்படுத்தப்படும் முதன்மை தரவு அமைப்பு கட்டுப்பாட்டுப் பாய்ச்சல் வரைபடம் (CFG) ஆகும்.

கட்டுப்பாட்டுப் பாய்ச்சல் வரைபடம் (CFG) என்றால் என்ன?

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

• நோட்கள் (அல்லது அடிப்படை தொகுதிகள்): தொடக்கத்திலும் முடிவிலும் தவிர, உள்ளேயும் வெளியேயும் கிளைகள் இல்லாத தொடர்ச்சியான அறிக்கைகளின் வரிசை. ஒரு தொகுதியின் முதல் அறிக்கையில் இருந்து எப்போதும் செயல்படுத்தல் தொடங்குகிறது மற்றும் இடைநிறுத்தம் அல்லது கிளை இல்லாமல் கடைசி ஒன்றுக்கு தொடர்கிறது.
• எட்ஜ்கள்: இவை கட்டுப்பாட்டின் ஓட்டம் அல்லது அடிப்படை தொகுதிகளுக்கு இடையே உள்ள 'ஜம்ப்களை' குறிக்கின்றன. உதாரணமாக, ஒரு `if` அறிக்கை, இரண்டு வெளிச்செல்லும் எட்ஜ்களுடன் ஒரு நோட்டை உருவாக்குகிறது: ஒன்று 'உண்மை' பாதைக்கும் மற்றொன்று 'தவறான' பாதைக்கும்.

ஒரு எளிய `if-else` அறிக்கைக்கு ஒரு CFG ஐ காட்சிப்படுத்தலாம்:

let x: string | number = ...;

if (typeof x === 'string') { // தொகுதி A (நிபந்தனை)
console.log(x.length); // தொகுதி B (உண்மை கிளை)
} else {
console.log(x + 1); // தொகுதி C (தவறான கிளை)
}

console.log('Done'); // தொகுதி D (இணைப்பு புள்ளி)

கருத்தியல் CFG இப்படி இருக்கும்:

[ நுழைவு ] --> [ தொகுதி A: `typeof x === 'string'` ] --> (உண்மை எட்ஜ்) --> [ தொகுதி B ] --> [ தொகுதி D ]

                                                                         \-> (தவறான எட்ஜ்) --> [ தொகுதி C ] --/

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

வகை சுருக்குதலுக்கான கட்டுப்பாட்டுப் பாய்ச்சல் பகுப்பாய்வை செயல்படுத்துதல்: ஒரு கருத்தியல் நடை

சுருக்குதலுக்காக CFA ஐப் பயன்படுத்தும் வகை சரிபார்ப்பை உருவாக்கும் செயல்முறையை உடைப்போம். ரஸ்ட் அல்லது சி++ போன்ற மொழியில் ஒரு நிஜ உலக செயல்படுத்தல் நம்பமுடியாத சிக்கலானது என்றாலும், முக்கிய கருத்துக்கள் புரிந்துகொள்ளத்தக்கவை.

படி 1: கட்டுப்பாட்டுப் பாய்ச்சல் வரைபடத்தை உருவாக்குதல் (CFG)

எந்த கம்பைலருக்கும் முதல் படி மூலக் குறியீட்டை சுருக்கத் தொடரியல் மரமாக (AST) அலசுவது. AST குறியீட்டின் தொடரியல் கட்டமைப்பைக் குறிக்கிறது. CFG பின்னர் இந்த AST இலிருந்து கட்டப்படுகிறது.

CFG ஐ உருவாக்குவதற்கான வழிமுறை பொதுவாக பின்வருவனவற்றை உள்ளடக்கியது:

1. அடிப்படை தொகுதி தலைவர்களை அடையாளம் காணுதல்: ஒரு அறிக்கை ஒரு தலைவராக இருந்தால் (ஒரு புதிய அடிப்படை தொகுதியின் தொடக்கம்):
   • நிரலில் உள்ள முதல் அறிக்கை.
   • ஒரு கிளையின் இலக்கு (எ.கா., `if` அல்லது `else` தொகுதிக்குள் உள்ள குறியீடு, ஒரு சுழற்சியின் தொடக்கம்).
   • ஒரு கிளை அல்லது ரிட்டர்ன் அறிக்கையை உடனடியாகத் தொடர்ந்து வரும் அறிக்கை.
2. தொகுதிகளை உருவாக்குதல்: ஒவ்வொரு தலைவருக்கும், அதன் அடிப்படைத் தொகுதி தலைவரை உள்ளடக்கியது மற்றும் அனைத்து அடுத்தடுத்த அறிக்கைகளையும் உள்ளடக்கியது, ஆனால் அடுத்த தலைவரை உள்ளடக்கவில்லை.
3. எட்ஜ்களைச் சேர்த்தல்: ஓட்டத்தைக் குறிக்க தொகுதிகளுக்கு இடையே எட்ஜ்கள் வரையப்படுகின்றன. `if (condition)` போன்ற நிபந்தனை அறிக்கை நிபந்தனையின் தொகுதியிலிருந்து 'உண்மை' தொகுதிக்கும் மற்றொன்று 'தவறான' தொகுதிக்கும் (அல்லது `else` இல்லையென்றால் உடனடியாகத் தொடர்ந்து வரும் தொகுதிக்கும்) ஒரு எட்ஜை உருவாக்குகிறது.

படி 2: நிலை இடம் - வகை தகவலைக் கண்காணித்தல்

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

// குறியீட்டில் கொடுக்கப்பட்ட புள்ளியில் கருத்தியல் நிலை interface TypeState { [variableName: string]: Type; }

ஒவ்வொரு மாறிக்கும் அதன் அறிவிக்கப்பட்ட வகை இருக்கும் ஆரம்ப நிலையுடன் செயல்பாடு அல்லது நிரலின் நுழைவு புள்ளியில் பகுப்பாய்வு தொடங்குகிறது. எங்கள் முந்தைய எடுத்துக்காட்டுக்கு, ஆரம்ப நிலை: { x: String | Number }. இந்த நிலை பின்னர் வரைபடம் முழுவதும் பரப்பப்படுகிறது.

படி 3: நிபந்தனை காவலர்களைப் பகுப்பாய்வு செய்தல் (முக்கிய தர்க்கம்)

இங்கே சுருக்குதல் நடக்கிறது. நிபந்தனை கிளை (ஒரு `if`, `while` அல்லது `switch` நிபந்தனை) ஐ பிரதிநிதித்துவப்படுத்தும் ஒரு நோடை பகுப்பாய்வி சந்திக்கும்போது, அது நிபந்தனையை தானே ஆராய்கிறது. நிபந்தனையின் அடிப்படையில், அது இரண்டு வெவ்வேறு வெளியீட்டு நிலைகளை உருவாக்குகிறது: ஒன்று நிபந்தனை உண்மையாக இருக்கும் பாதைக்கும், மற்றொன்று அது தவறான பாதைக்கும்.

காவலரை பகுப்பாய்வு செய்வோம் typeof x === 'string':

• 'உண்மை' கிளை: பகுப்பாய்வி இந்த வடிவத்தை அங்கீகரிக்கிறது. இந்த வெளிப்பாடு உண்மையாக இருந்தால், `x` இன் வகை `string` ஆக இருக்க வேண்டும் என்று அது அறிந்துள்ளது. எனவே, அது அதன் வரைபடத்தைப் புதுப்பித்து 'உண்மை' பாதைக்கு ஒரு புதிய நிலையை உருவாக்குகிறது:

  உள்ளீட்டு நிலை: { x: String | Number }

  உண்மைப் பாதைக்கான வெளியீட்டு நிலை: { x: String }

  இந்த புதிய, மேலும் துல்லியமான நிலை பின்னர் உண்மை கிளையில் உள்ள அடுத்த தொகுதிக்கு (தொகுதி B) பரப்பப்படுகிறது. தொகுதி B க்குள், `x` இல் உள்ள எந்த செயல்பாடுகளும் `String` வகைக்கு எதிராக சரிபார்க்கப்படும்.
• 'தவறான' கிளை: இதுவும் முக்கியமானது. typeof x === 'string' தவறாக இருந்தால், `x` பற்றி அது என்ன சொல்கிறது? பகுப்பாய்வி 'உண்மை' வகையை அசல் வகையிலிருந்து கழிக்க முடியும்.

  உள்ளீட்டு நிலை: { x: String | Number }

  நீக்க வேண்டிய வகை: String

  தவறான பாதைக்கான வெளியீட்டு நிலை: { x: Number } (ஏனெனில் (String | Number) - String = Number)

  இந்த சுத்திகரிக்கப்பட்ட நிலை 'தவறான' பாதைக்கு தொகுதி C க்கு கீழே பரப்பப்படுகிறது. தொகுதி C க்குள், `x` சரியாக ஒரு `Number` ஆக கருதப்படுகிறது.

பகுப்பாய்வி பல்வேறு வடிவங்களைப் புரிந்து கொள்ள உள்ளமைக்கப்பட்ட தர்க்கத்தைக் கொண்டிருக்க வேண்டும்:

• x instanceof C: உண்மை பாதையில், `x` இன் வகை `C` ஆக மாறும். தவறான பாதையில், அது அதன் அசல் வகையாகவே உள்ளது.
• x != null: உண்மை பாதையில், `Null` மற்றும் `Undefined` `x` இன் வகையிலிருந்து அகற்றப்படும்.
• shape.kind === 'circle': `shape` ஒரு வேறுபடுத்தப்பட்ட யூனியனாக இருந்தால், அதன் வகை `kind` என்பது நேரடி வகை `'circle'` ஆக இருக்கும் உறுப்பினருக்கு சுருக்கப்படுகிறது.

படி 4: கட்டுப்பாட்டுப் பாய்ச்சல் பாதைகளை இணைத்தல்

எங்கள் `if-else` அறிக்கைக்குப் பிறகு தொகுதி D இல் உள்ளதைப் போல கிளைகள் மீண்டும் இணையும்போது என்ன நடக்கும்? பகுப்பாய்வி இந்த இணைப்பு புள்ளியில் வரும் இரண்டு வெவ்வேறு நிலைகளைக் கொண்டுள்ளது:

• தொகுதி B இலிருந்து (உண்மை பாதை): { x: String }
• தொகுதி C இலிருந்து (தவறான பாதை): { x: Number }

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

தொகுதி D க்கான இணைக்கப்பட்ட நிலை: { x: Union(String, Number) } இது { x: String | Number } ஆக எளிதாக்குகிறது.

`x` இன் வகை அதன் அசல், பரந்த வகைக்குத் திரும்புகிறது, ஏனெனில் நிரலில் இந்த கட்டத்தில், அது எந்த கிளையிலிருந்தும் வந்திருக்கலாம். அதனால்தான் நீங்கள் `if-else` தொகுதிக்குப் பிறகு `x.toUpperCase()` ஐப் பயன்படுத்த முடியாது—வகை பாதுகாப்பு உத்தரவாதம் போய்விட்டது.

படி 5: சுழற்சிகள் மற்றும் ஒதுக்கீடுகளைக் கையாளுதல்

• ஒதுக்கீடுகள்: ஒரு மாறிக்கு ஒதுக்கீடு செய்வது CFA க்கு ஒரு முக்கியமான நிகழ்வு. பகுப்பாய்வி x = 10; ஐப் பார்த்தால், அது `x` க்கு இருந்த முந்தைய சுருக்கும் தகவலை நிராகரிக்க வேண்டும். `x` இன் வகை இப்போது உறுதியாக ஒதுக்கப்பட்ட மதிப்பின் வகை (`Number` இந்த விஷயத்தில்). இந்த செல்லாததாக்குதல் சரியானதுக்கு முக்கியமானது. டெவலப்பர் குழப்பத்தின் ஒரு பொதுவான ஆதாரம் என்னவென்றால், ஒரு சுருக்கப்பட்ட மாறி ஒரு மூடுதலுக்குள் மறு ஒதுக்கீடு செய்யப்படுகிறது, இது அதற்கு வெளியே சுருக்குதலை செல்லாததாக்குகிறது.
• சுழற்சிகள்: சுழற்சிகள் CFG இல் சுழற்சிகளை உருவாக்குகின்றன. ஒரு சுழற்சியின் பகுப்பாய்வு மிகவும் சிக்கலானது. பகுப்பாய்வி சுழற்சி உடலைச் செயலாக்க வேண்டும், பின்னர் சுழற்சியின் முடிவில் உள்ள நிலை தொடக்கத்தில் உள்ள நிலையை எவ்வாறு பாதிக்கிறது என்பதைப் பார்க்கவும். அது சுழற்சி உடலை பலமுறை மறு பகுப்பாய்வு செய்ய வேண்டியிருக்கலாம், ஒவ்வொரு முறையும் வகைகளை சுத்திகரிக்கிறது, வகை தகவல் நிலையாகும் வரை—ஒரு செயல்முறை நிலையான புள்ளி ஐ அடைவதாக அறியப்படுகிறது. உதாரணமாக, ஒரு `for...of` சுழற்சியில், ஒரு மாறியின் வகை சுழற்சியில் சுருக்கப்படலாம், ஆனால் இந்த சுருக்குதல் ஒவ்வொரு மறு செய்கையிலும் மீட்டமைக்கப்படுகிறது.

அடிப்படைக்கு அப்பால்: மேம்பட்ட CFA கருத்துக்கள் மற்றும் சவால்கள்

மேலே உள்ள எளிய மாதிரி அடிப்படைகளை உள்ளடக்கியது, ஆனால் நிஜ உலக காட்சிகள் குறிப்பிடத்தக்க சிக்கலை அறிமுகப்படுத்துகின்றன.

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

டைப்ஸ்கிரிப்ட் போன்ற நவீன மொழிகள் டெவலப்பர்களை CFA அமைப்புக்கு குறிப்புகளை வழங்க அனுமதிக்கின்றன. பயனர் வரையறுத்த வகை காவலாளியானது, திரும்பும் வகை ஒரு சிறப்பு வகை முன்னறிவிப்பு ஆகும்.

function isUser(obj: any): obj is User {
return obj && typeof obj.name === 'string';
}

திரும்பும் வகை obj is User வகை சரிபார்ப்பவருக்குக் கூறுகிறது: "இந்தச் செயல்பாடு `உண்மை` என்பதைத் திருப்பினால், ஆர்கியூமென்ட் `obj` `User` வகையைக் கொண்டுள்ளது என்று நீங்கள் கருதலாம்."

CFA if (isUser(someVar)) { ... } ஐ சந்திக்கும்போது, அது செயல்பாட்டின் உள் தர்க்கத்தைப் புரிந்து கொள்ளத் தேவையில்லை. அது கையொப்பத்தை நம்புகிறது. 'உண்மை' பாதையில், அது someVar ஐ `User` க்கு சுருக்குகிறது. இது உங்கள் பயன்பாட்டின் களத்திற்கு குறிப்பிட்ட புதிய சுருக்கும் வடிவங்களை பகுப்பாய்விக்கு கற்பிப்பதற்கான விரிவாக்கக்கூடிய வழியாகும்.

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

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

const { kind, radius } = shape; // shape என்பது Circle | Square

if (kind === 'circle') {
// இங்கே, 'kind' 'வட்ட'த்திற்கு சுருக்கப்பட்டது.
// ஆனால் பகுப்பாய்விக்கு 'shape' இப்போது வட்டமாக இருக்கிறதா என்று தெரியுமா?
console.log(radius); // TS இல், இது தோல்வியடைகிறது! 'radius' 'shape' இல் இல்லை.
}

மேலே உள்ள எடுத்துக்காட்டில், உள்ளூர் மாறிலி kind ஐ சுருக்குவது அசல் `shape` பொருளை தானாக சுருக்காது. ஏனென்றால், `shape` வேறு எங்கும் மறு ஒதுக்கீடு செய்யப்படலாம். இருப்பினும், நீங்கள் சொத்தை நேரடியாகச் சரிபார்த்தால், அது வேலை செய்கிறது:

if (shape.kind === 'circle') {
// இது வேலை செய்கிறது! CFA `shape` தன்னைச் சரிபார்க்கிறது என்று தெரியும். console.log(shape.radius); }

ஒரு அதிநவீன CFA மாறிகளை மட்டுமல்ல, மாறிகளின் பண்புகளையும் கண்காணிக்க வேண்டும், மேலும் ஒரு மாற்றுப்பெயர் எப்போது 'பாதுகாப்பானது' என்பதைப் புரிந்து கொள்ள வேண்டும் (எ.கா., அசல் பொருள் ஒரு `const` ஆக இருந்தால், மறு ஒதுக்கீடு செய்ய முடியாது).

மூடுதல்கள் மற்றும் உயர்-வரிசை செயல்பாடுகளின் தாக்கம்

செயல்பாடுகள் ஆர்கியூமென்ட்களாக அனுப்பப்படும்போது அல்லது மூடுதல்கள் அவற்றின் பெற்றோர் வரம்பிலிருந்து மாறிகளைப் பிடிக்கும்போது கட்டுப்பாட்டு ஓட்டம் நேரியல் அல்லாததாகி பகுப்பாய்வு செய்வது மிகவும் கடினமாகிறது. இதை கவனியுங்கள்:

function process(value: string | null) {
if (value === null) {
return;
}

// இந்த கட்டத்தில், CFA க்கு 'value' ஒரு சரம் என்று தெரியும்.
setTimeout(() => {
// திரும்ப அழைப்புக்குள், இங்கே 'value' இன் வகை என்ன? console.log(value.toUpperCase()); // இது பாதுகாப்பானதா? }, 1000); }

இது பாதுகாப்பானதா? இது சார்ந்தது. நிரலின் மற்றொரு பகுதி `setTimeout` அழைப்புக்கும் அதன் செயல்பாட்டிற்கும் இடையில் `value` ஐ மாற்றியமைக்க முடியுமானால், சுருக்குதல் செல்லாது. டைப்ஸ்கிரிப்ட்டின் உட்பட பெரும்பாலான வகை சரிபார்ப்பாளர்கள் இங்கே பழமைவாதிகள். மாற்றக்கூடிய மூடுதலில் கைப்பற்றப்பட்ட மாறி மாறக்கூடும் என்று அவர்கள் கருதுகிறார்கள், எனவே வெளிப்புற வரம்பில் செய்யப்படும் சுருக்குதல் மாறி ஒரு `const` ஆக இல்லாவிட்டால், பெரும்பாலும் திரும்ப அழைப்புக்குள் இழக்கப்படுகிறது.

`never` உடன் சோர்வுத்தன்மை சரிபார்ப்பு

CFA இன் மிகவும் சக்திவாய்ந்த பயன்பாடுகளில் ஒன்று சோர்வுத்தன்மை சோதனைகளை இயக்குகிறது. `never` வகை என்பது ஒருபோதும் நிகழக்கூடாத மதிப்பைக் குறிக்கிறது. வேறுபடுத்தப்பட்ட யூனியனில் ஒரு `switch` அறிக்கையில், ஒவ்வொரு வழக்கையும் நீங்கள் கையாளும்போது, CFA கையாளப்பட்ட வழக்கைக் கழித்து மாறியின் வகையை சுருக்குகிறது.

function getArea(shape: Shape) { // Shape என்பது Circle | Square switch (shape.kind) { case 'circle': // இங்கே, வடிவம் வட்டம் return Math.PI * shape.radius ** 2; case 'square': // இங்கே, வடிவம் சதுரம் return shape.sideLength ** 2; default: // இங்கே 'shape' இன் வகை என்ன? // இது (Circle | Square) - Circle - Square = never const _exhaustiveCheck: never = shape; return _exhaustiveCheck; } }

நீங்கள் பின்னர் `Triangle` ஐ `Shape` யூனியனில் சேர்த்தால், ஆனால் அதற்கான `case` ஐச் சேர்க்க மறந்துவிட்டால், `default` கிளை அடையக்கூடியதாக இருக்கும். அந்த கிளையில் உள்ள `shape` இன் வகை `Triangle` ஆக இருக்கும். `never` வகை மாறியிக்கு `Triangle` ஐ ஒதுக்க முயற்சிப்பது ஒரு கம்பைல் நேர பிழையை ஏற்படுத்தும், உங்கள் `switch` அறிக்கை இனி சோர்வு அடையவில்லை என்பதை உடனடியாக உங்களுக்கு எச்சரிக்கிறது. இது CFA ஒரு முழுமையற்ற தர்க்கத்திற்கு எதிராக ஒரு வலுவான பாதுகாப்பு வலையை வழங்குகிறது.

டெவலப்பர்களுக்கான நடைமுறை தாக்கங்கள்

CFA இன் கொள்கைகளைப் புரிந்துகொள்வது உங்களை ஒரு திறமையான நிரலாக்கராக மாற்றும். நீங்கள் சரியான குறியீட்டை எழுதுவது மட்டுமல்லாமல், வகை சரிபார்ப்புடன் 'நன்றாக விளையாடுகிறது', தெளிவான குறியீடு மற்றும் குறைவான வகை தொடர்பான போர்களுக்கு வழிவகுக்கும்.

• கணிப்பு சுருக்குவதற்கு `const` ஐ விரும்பவும்: ஒரு மாறியை மறு ஒதுக்கீடு செய்ய முடியாதபோது, பகுப்பாய்வி அதன் வகையைப் பற்றி வலுவான உத்தரவாதங்களை வழங்க முடியும். `let` ஐ விட `const` ஐப் பயன்படுத்துவது மூடுதல்கள் உட்பட அதிக சிக்கலான வரம்புகளில் சுருக்குதலைப் பாதுகாக்க உதவுகிறது.
• வேறுபடுத்தப்பட்ட யூனியன்களைத் தழுவுங்கள்: ஒரு நேரடி சொத்துடன் (போன்ற `kind` அல்லது `type`) உங்கள் தரவு கட்டமைப்புகளை வடிவமைப்பது CFA அமைப்புக்கு நோக்கத்தை சமிக்ஞை செய்வதற்கான மிகவும் வெளிப்படையான மற்றும் சக்திவாய்ந்த வழி. இந்த யூனியன்களில் `switch` அறிக்கைகள் தெளிவாகவும், திறமையாகவும் உள்ளன, மேலும் சோர்வுத்தன்மை சரிபார்ப்புக்கு அனுமதிக்கின்றன.
• நேரடி சோதனைகளை வைத்திருங்கள்: மாற்றுப்பெயரிடலில் காணப்பட்டதைப் போல, ஒரு பொருளின் மீதான சொத்தை நேரடியாகச் சரிபார்க்கிறது (`obj.prop`) சொத்தை உள்ளூர் மாறிக்கு நகலெடுத்து அதைச் சரிபார்ப்பதை விட சுருக்குவதற்கு மிகவும் நம்பகமானது.
• CFA ஐ மனதில் கொண்டு பிழைத்திருத்தம் செய்யுங்கள்: ஒரு வகை சுருக்கப்பட்டிருக்க வேண்டும் என்று நீங்கள் நினைக்கும் இடத்தில் ஒரு வகை பிழையை நீங்கள் சந்திக்கும்போது, கட்டுப்பாட்டு ஓட்டத்தைப் பற்றி சிந்தியுங்கள். மாறி எங்காவது மறு ஒதுக்கீடு செய்யப்பட்டதா? பகுப்பாய்வியால் முழுமையாக புரிந்து கொள்ள முடியாத ஒரு மூடுதலுக்குள் அது பயன்படுத்தப்படுகிறதா? இந்த மன மாதிரி ஒரு சக்திவாய்ந்த பிழைத்திருத்தும் கருவியாகும்.

முடிவு: வகை பாதுகாப்பின் அமைதியான பாதுகாவலர்

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

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