முக்கிய உள்ளடக்கத்திற்குச் செல்லவும்
தொகுதி 3 · பாடம் 2 இன் 2பாடத்திட்டத்தில் 6/14~15 min
தொகுதி பாடங்கள் (2/2)

அடிப்படை ஜெனரிக்ஸ்

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


பொதுவான செயல்பாடுகள்

வகைகளுக்கான மாறியாக ஒரு பொதுவானவை என்று கருதுங்கள். அதற்கு அனுப்பப்பட்ட மதிப்பை ஒரு வாதமாக வழங்கும் செயல்பாட்டைக் கருத்தில் கொள்வோம்:

TS
function identity<T>(arg: T): T {
  return arg;
}

T எழுத்து (Type என்பதன் சுருக்கம்) வகைக்கான ஒதுக்கிடமாகும். நாம் identity ஐ அழைக்கும் போது, ​​TypeScript ஆனது அனுப்பப்பட்ட வாதத்தின் வகையைப் படம்பிடித்து, தானாகவே T ஐ அந்த வகைக்கு அமைக்கிறது:

TS
const str = identity<string>('Hello'); // T is string
const num = identity(42); // T is number (automatically inferred!)

பொதுவான இடைமுகங்கள் மற்றும் மாற்றுப்பெயர்கள்

பொதுவான கொள்கலன்கள் அல்லது தரவு கட்டமைப்புகளை வரையறுக்க இடைமுகங்கள் மற்றும் வகை மாற்றுப்பெயர்களுக்கும் ஜெனரிக்ஸ் பயன்படுத்தப்படலாம்:

TS
interface Box<T> {
  content: T;
}

const stringBox: Box<string> = { content: 'TypeScript' };
const numberBox: Box<number> = { content: 42 };

பல வகை அளவுருக்கள்

பல வகை மாறிகளைப் பயன்படுத்தும் செயல்பாடுகள் அல்லது வகைகளை நாம் வரையறுக்கலாம் (எ.கா., T மற்றும் U):

TS
function mergeObjects<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

பொதுவான கட்டுப்பாடுகள்

சில சமயங்களில் பொதுவான வகைகளால் ஏற்றுக்கொள்ளப்பட்ட வகைகளைக் கட்டுப்படுத்த விரும்புகிறோம். தடையைச் சேர்க்க extends முக்கிய சொல்லைப் பயன்படுத்தலாம்.

எடுத்துக்காட்டாக, பொதுவான வகை எப்போதும் length பண்பு (சரங்கள் அல்லது வரிசைகள் போன்றவை) இருக்க வேண்டும் என நாங்கள் விரும்பினால்:

TS
interface HasLength {
  length: number;
}

function logLength<T extends HasLength>(arg: T): void {
  console.log(arg.length); // Safe! We know arg has 'length'
}

logLength('Hello'); // Valid
logLength([1, 2, 3]); // Valid
// logLength(42); // Error: number does not have a length property!

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

பயிற்சி 1: பொதுவான அடையாள செயல்பாடு

உடற்பயிற்சி#ts.m3.l2.e1
முயற்சிகள்: 0ஏற்றுகிறது…

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

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

திரும்பும் வகையானது அளவுருவின் அதே பொதுவான வகை T ஆக இருக்க வேண்டும்.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

பயிற்சி 2: பொதுவான பெட்டி ரேப்பர்

உடற்பயிற்சி#ts.m3.l2.e2
முயற்சிகள்: 0ஏற்றுகிறது…

T வகை அளவுருவை ஏற்கும் மற்றும் T வகையின் உள்ளடக்கம் என்று பெயரிடப்பட்ட ஒற்றைப் பண்பு கொண்ட Box என்ற பெயரிடப்பட்ட பொதுவான இடைமுகத்தை வரையறுக்கவும்.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

இடைமுகப் பெட்டியைப் பயன்படுத்தவும்<T> {content: T; } தொடரியல்.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

பயிற்சி 3: பொதுவான கட்டுப்பாடு

உடற்பயிற்சி#ts.m3.l2.e3
முயற்சிகள்: 0ஏற்றுகிறது…

arg அளவுருவை ஏற்கும் getLength என்ற பொதுவான செயல்பாட்டை எழுதவும். arg ஒரு நீளமான பண்பு (எண்) கொண்ட ஒரு இடைமுகத்திற்கு கட்டுப்படுத்தப்பட வேண்டும். செயல்பாடு arg.length ஐ வழங்க வேண்டும்.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

செயல்பாட்டை getLength<T நீட்டிக்கிறது HasLength>(arg: T): எண் மற்றும் arg.length என அறிவிக்கவும்.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

பயிற்சி 4: பொதுவான ஜோடி

உடற்பயிற்சி#ts.m3.l2.e4
முயற்சிகள்: 0ஏற்றுகிறது…

இரண்டு பண்புகள் கொண்ட பொதுவான இடைமுகம் ஜோடி<T, U> ஐ வரையறுக்கவும்: முதல் வகை T மற்றும் இரண்டாவது வகை U. அடுத்து, ஒரு பொதுவான செயல்பாட்டை உருவாக்கவும், இது முதல் (T வகை) மற்றும் இரண்டாவது (வகை U) ஆகியவற்றை ஏற்றுக்கொண்டு, ஜோடி<T, U> செயல்படுத்தும் பொருளை வழங்கும்.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

ஜோடி<T, U> என்ற இரண்டு பொதுவான அளவுருக்களுக்கு தொடரியல் பயன்படுத்தவும் மற்றும் அதன்படி makePair ஐ வரையறுக்கவும்.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்