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

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

மாட்யூல் ஆக்மென்டேஷன் என்றால் என்ன?

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

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

மாட்யூல் ஆக்மென்டேஷனை ஏன் பயன்படுத்த வேண்டும்?

உங்கள் டைப்ஸ்கிரிப்ட் ஆயுதக் களஞ்சியத்தில் மாட்யூல் ஆக்மென்டேஷன் ஏன் ஒரு மதிப்புமிக்க கருவி என்பது இங்கே:

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

மாட்யூல் ஆக்மென்டேஷன் எவ்வாறு செயல்படுகிறது

முக்கியக் கருத்து declare module தொடரியலைச் சுற்றியே உள்ளது. இதோ பொதுவான கட்டமைப்பு:

declare module 'module-name' {
  // Type declarations to augment the module
  interface ExistingInterface {
    newProperty: string;
  }
}

முக்கியப் பகுதிகளைப் பிரித்துப் பார்ப்போம்:

• declare module 'module-name': இது 'module-name' என்ற பெயரிடப்பட்ட மாட்யூலை நீங்கள் ஆக்மென்ட் செய்கிறீர்கள் என்று அறிவிக்கிறது. இது உங்கள் குறியீட்டில் இறக்குமதி செய்யப்பட்ட சரியான மாட்யூல் பெயருடன் பொருந்த வேண்டும்.
• declare module பிளாக்கின் உள்ளே, நீங்கள் சேர்க்க அல்லது மாற்றியமைக்க விரும்பும் வகை அறிவிப்புகளை வரையறுக்கிறீர்கள். நீங்கள் இன்டர்ஃபேஸ்கள், வகைகள், கிளாஸ்கள், செயல்பாடுகள் அல்லது மாறிகளைச் சேர்க்கலாம்.
• நீங்கள் ஏற்கனவே உள்ள ஒரு இன்டர்ஃபேஸ் அல்லது கிளாஸை ஆக்மென்ட் செய்ய விரும்பினால், அசல் வரையறையின் அதே பெயரைப் பயன்படுத்தவும். டைப்ஸ்கிரிப்ட் உங்கள் சேர்த்தல்களை அசல் வரையறையுடன் தானாகவே இணைக்கும்.

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

எடுத்துக்காட்டு 1: ஒரு மூன்றாம் தரப்பு நூலகத்தை விரிவுபடுத்துதல் (Moment.js)

நீங்கள் தேதி மற்றும் நேரத்தைக் கையாள Moment.js நூலகத்தைப் பயன்படுத்துகிறீர்கள் என்றும், ஒரு குறிப்பிட்ட லோகேலுக்காக (எ.கா., ஜப்பானில் ஒரு குறிப்பிட்ட வடிவத்தில் தேதிகளைக் காண்பிக்க) ஒரு தனிப்பயன் வடிவமைப்பு விருப்பத்தைச் சேர்க்க விரும்புகிறீர்கள் என்றும் வைத்துக்கொள்வோம். அசல் Moment.js வகை வரையறைகளில் இந்த தனிப்பயன் வடிவம் இல்லாமல் இருக்கலாம். இதைச் சேர்க்க மாட்யூல் ஆக்மென்டேஷனை எவ்வாறு பயன்படுத்தலாம் என்பது இங்கே:

1. Moment.js க்கான வகை வரையறைகளை நிறுவவும்:

   
   npm install @types/moment
   

2. உங்கள் ஆக்மென்டேஷனை வரையறுக்க ஒரு டைப்ஸ்கிரிப்ட் கோப்பை (எ.கா., moment.d.ts) உருவாக்கவும்:

   
   // moment.d.ts
   import 'moment'; // Import the original module to ensure it's available
   
   declare module 'moment' {
     interface Moment {
       formatInJapaneseStyle(): string;
     }
   }
   

3. தனிப்பயன் வடிவமைப்பு லாஜிக்கை செயல்படுத்தவும் (ஒரு தனி கோப்பில், எ.கா., moment-extensions.ts):

   
   // moment-extensions.ts
   import * as moment from 'moment';
   
   moment.fn.formatInJapaneseStyle = function(): string {
     // Custom formatting logic for Japanese dates
     const year = this.year();
     const month = this.month() + 1; // Month is 0-indexed
     const day = this.date();
     return `${year}年${month}月${day}日`;
   };
   

4. ஆக்மென்ட் செய்யப்பட்ட Moment.js ஆப்ஜெக்டைப் பயன்படுத்தவும்:

   
   // app.ts
   import * as moment from 'moment';
   import './moment-extensions'; // Import the implementation
   
   const now = moment();
   const japaneseFormattedDate = now.formatInJapaneseStyle();
   console.log(japaneseFormattedDate); // Output: e.g., 2024年1月26日
   

விளக்கம்:

• நாங்கள் ஏற்கனவே உள்ள மாட்யூலை ஆக்மென்ட் செய்கிறோம் என்பதை டைப்ஸ்கிரிப்ட்டுக்குத் தெரிவிக்க, அசல் moment மாட்யூலை moment.d.ts கோப்பில் இறக்குமதி செய்கிறோம்.
• moment மாட்யூலுக்குள் உள்ள Moment இன்டர்ஃபேஸில் formatInJapaneseStyle என்ற புதிய மெத்தடை நாங்கள் அறிவிக்கிறோம்.
• moment-extensions.ts இல், புதிய மெத்தடின் உண்மையான செயலாக்கத்தை moment.fn ஆப்ஜெக்டில் (இது Moment ஆப்ஜெக்ட்களின் ப்ரோட்டோடைப்) சேர்க்கிறோம்.
• இப்போது, உங்கள் பயன்பாட்டில் உள்ள எந்த Moment ஆப்ஜெக்டிலும் formatInJapaneseStyle மெத்தடைப் பயன்படுத்தலாம்.

எடுத்துக்காட்டு 2: ஒரு Request ஆப்ஜெக்டில் பண்புகளைச் சேர்த்தல் (Express.js)

நீங்கள் Express.js ஐப் பயன்படுத்துகிறீர்கள் என்றும், மிடில்வேர் மூலம் நிரப்பப்படும் userId போன்ற ஒரு தனிப்பயன் பண்பை Request ஆப்ஜெக்டில் சேர்க்க விரும்புகிறீர்கள் என்றும் வைத்துக்கொள்வோம். மாட்யூல் ஆக்மென்டேஷன் மூலம் இதை எவ்வாறு அடையலாம் என்பது இங்கே:

1. Express.js க்கான வகை வரையறைகளை நிறுவவும்:

   
   npm install @types/express
   

2. உங்கள் ஆக்மென்டேஷனை வரையறுக்க ஒரு டைப்ஸ்கிரிப்ட் கோப்பை (எ.கா., express.d.ts) உருவாக்கவும்:

   
   // express.d.ts
   import 'express'; // Import the original module
   
   declare module 'express' {
     interface Request {
       userId?: string;
     }
   }
   

3. உங்கள் மிடில்வேரில் ஆக்மென்ட் செய்யப்பட்ட Request ஆப்ஜெக்டைப் பயன்படுத்தவும்:

   
   // middleware.ts
   import { Request, Response, NextFunction } from 'express';
   
   export function authenticateUser(req: Request, res: Response, next: NextFunction) {
     // Authentication logic (e.g., verifying a JWT)
     const userId = 'user123'; // Example: Retrieve user ID from token
     req.userId = userId; // Assign the user ID to the Request object
     next();
   }
   

4. உங்கள் ரூட் ஹேண்ட்லர்களில் userId பண்பை அணுகவும்:

   
   // routes.ts
   import { Request, Response } from 'express';
   
   export function getUserProfile(req: Request, res: Response) {
     const userId = req.userId;
     if (!userId) {
       return res.status(401).send('Unauthorized');
     }
   
     // Retrieve user profile from database based on userId
     const userProfile = { id: userId, name: 'John Doe' }; // Example
     res.json(userProfile);
   }
   

விளக்கம்:

• அசல் express மாட்யூலை express.d.ts கோப்பில் இறக்குமதி செய்கிறோம்.
• express மாட்யூலுக்குள் உள்ள Request இன்டர்ஃபேஸில் userId என்ற புதிய பண்பை (? குறியீட்டால் விருப்பமானது என குறிக்கப்பட்டுள்ளது) நாங்கள் அறிவிக்கிறோம்.
• authenticateUser மிடில்வேரில், req.userId பண்பிற்கு ஒரு மதிப்பை நாங்கள் ஒதுக்குகிறோம்.
• getUserProfile ரூட் ஹேண்ட்லரில், req.userId பண்பை நாங்கள் அணுகுகிறோம். மாட்யூல் ஆக்மென்டேஷன் காரணமாக டைப்ஸ்கிரிப்ட் இந்தப் பண்பைப் பற்றி அறிந்திருக்கிறது.

எடுத்துக்காட்டு 3: HTML கூறுகளுக்கு தனிப்பயன் பண்புகளைச் சேர்த்தல்

ரியாக்ட் அல்லது வ்யூ.js போன்ற நூலகங்களுடன் பணிபுரியும் போது, நீங்கள் HTML கூறுகளுக்கு தனிப்பயன் பண்புகளைச் சேர்க்க விரும்பலாம். மாட்யூல் ஆக்மென்டேஷன் இந்த தனிப்பயன் பண்புகளுக்கான வகைகளை வரையறுக்க உதவும், இது உங்கள் டெம்ப்ளேட்கள் அல்லது JSX குறியீட்டில் வகை பாதுகாப்பை உறுதி செய்கிறது.

நீங்கள் ரியாக்ட் பயன்படுத்துகிறீர்கள் என்றும், HTML கூறுகளுக்கு data-custom-id என்ற தனிப்பயன் பண்பைச் சேர்க்க விரும்புகிறீர்கள் என்றும் வைத்துக்கொள்வோம்.

1. உங்கள் ஆக்மென்டேஷனை வரையறுக்க ஒரு டைப்ஸ்கிரிப்ட் கோப்பை (எ.கா., react.d.ts) உருவாக்கவும்:

   
   // react.d.ts
   import 'react'; // Import the original module
   
   declare module 'react' {
     interface HTMLAttributes extends AriaAttributes, DOMAttributes {
       "data-custom-id"?: string;
     }
   }
   

2. உங்கள் ரியாக்ட் கூறுகளில் தனிப்பயன் பண்பைப் பயன்படுத்தவும்:

   
   // MyComponent.tsx
   import React from 'react';
   
   function MyComponent() {
     return (
       
    
         This is my component.
       
     );
   }
   
   export default MyComponent;
   

விளக்கம்:

• அசல் react மாட்யூலை react.d.ts கோப்பில் இறக்குமதி செய்கிறோம்.
• react மாட்யூலில் உள்ள HTMLAttributes இன்டர்ஃபேஸை நாங்கள் ஆக்மென்ட் செய்கிறோம். இந்த இன்டர்ஃபேஸ் ரியாக்டில் HTML கூறுகளுக்குப் பயன்படுத்தக்கூடிய பண்புகளை வரையறுக்கப் பயன்படுகிறது.
• HTMLAttributes இன்டர்ஃபேஸில் data-custom-id பண்பைச் சேர்க்கிறோம். ? இது ஒரு விருப்பப் பண்பு என்பதைக் குறிக்கிறது.
• இப்போது, உங்கள் ரியாக்ட் கூறுகளில் உள்ள எந்தவொரு HTML உறுப்பிலும் data-custom-id பண்பைப் பயன்படுத்தலாம், மேலும் டைப்ஸ்கிரிப்ட் அதை ஒரு சரியான பண்பாக அங்கீகரிக்கும்.

மாட்யூல் ஆக்மென்டேஷனுக்கான சிறந்த நடைமுறைகள்

• தனித்தனி டெக்ளரேஷன் கோப்புகளை உருவாக்கவும்: உங்கள் மாட்யூல் ஆக்மென்டேஷன் வரையறைகளைத் தனி .d.ts கோப்புகளில் (எ.கா., moment.d.ts, express.d.ts) சேமிக்கவும். இது உங்கள் குறியீட்டுத் தளத்தை ஒழுங்கமைத்து, வகை நீட்டிப்புகளை நிர்வகிப்பதை எளிதாக்குகிறது.
• அசல் மாட்யூலை இறக்குமதி செய்யவும்: எப்போதும் உங்கள் டெக்ளரேஷன் கோப்பின் மேலே அசல் மாட்யூலை இறக்குமதி செய்யவும் (எ.கா., import 'moment';). இது நீங்கள் ஆக்மென்ட் செய்யும் மாட்யூலைப் பற்றி டைப்ஸ்கிரிப்ட் அறிந்திருப்பதை உறுதிசெய்து, வகை வரையறைகளைச் சரியாக இணைக்க உதவுகிறது.
• மாட்யூல் பெயர்களில் குறிப்பாக இருங்கள்: declare module 'module-name' என்பதில் உள்ள மாட்யூல் பெயர், உங்கள் இறக்குமதி அறிக்கைகளில் பயன்படுத்தப்படும் மாட்யூல் பெயருடன் சரியாகப் பொருந்துவதை உறுதிசெய்யவும். கேஸ் சென்சிட்டிவிட்டி முக்கியம்!
• பொருத்தமான இடங்களில் விருப்பப் பண்புகளைப் பயன்படுத்தவும்: ஒரு புதிய பண்பு அல்லது மெத்தட் எப்போதும் இருக்காது என்றால், அதை விருப்பமானதாக மாற்ற ? குறியீட்டைப் பயன்படுத்தவும் (எ.கா., userId?: string;).
• எளிமையான நிகழ்வுகளுக்கு டெக்ளரேஷன் மெர்ஜிங்கைக் கருத்தில் கொள்ளுங்கள்: *அதே* மாட்யூலுக்குள் ஏற்கனவே உள்ள ஒரு இன்டர்ஃபேஸில் புதிய பண்புகளைச் சேர்க்கிறீர்கள் என்றால், மாட்யூல் ஆக்மென்டேஷனுக்கு பதிலாக டெக்ளரேஷன் மெர்ஜிங் ஒரு எளிய மாற்றாக இருக்கலாம்.
• உங்கள் ஆக்மென்டேஷன்களை ஆவணப்படுத்தவும்: நீங்கள் ஏன் வகைகளை விரிவுபடுத்துகிறீர்கள் மற்றும் நீட்டிப்புகளை எவ்வாறு பயன்படுத்த வேண்டும் என்பதை விளக்க உங்கள் ஆக்மென்டேஷன் கோப்புகளில் கருத்துக்களைச் சேர்க்கவும். இது குறியீட்டின் பராமரிப்பை மேம்படுத்துகிறது மற்றும் மற்ற டெவலப்பர்கள் உங்கள் நோக்கங்களைப் புரிந்துகொள்ள உதவுகிறது.
• உங்கள் ஆக்மென்டேஷன்களை சோதிக்கவும்: உங்கள் மாட்யூல் ஆக்மென்டேஷன்கள் எதிர்பார்த்தபடி செயல்படுகின்றனவா என்பதையும், அவை எந்த வகை பிழைகளையும் அறிமுகப்படுத்தவில்லை என்பதையும் சரிபார்க்க யூனிட் சோதனைகளை எழுதவும்.

பொதுவான இடர்களும் அவற்றை தவிர்ப்பதற்கான வழிகளும்

• தவறான மாட்யூல் பெயர்: declare module அறிக்கையில் தவறான மாட்யூல் பெயரைப் பயன்படுத்துவது மிகவும் பொதுவான தவறுகளில் ஒன்றாகும். பெயர் உங்கள் இறக்குமதி அறிக்கைகளில் பயன்படுத்தப்படும் மாட்யூல் அடையாளங்காட்டியுடன் சரியாகப் பொருந்துகிறதா என்பதை இருமுறை சரிபார்க்கவும்.
• விடுபட்ட இறக்குமதி அறிக்கை: உங்கள் டெக்ளரேஷன் கோப்பில் அசல் மாட்யூலை இறக்குமதி செய்ய மறப்பது வகை பிழைகளுக்கு வழிவகுக்கும். எப்போதும் உங்கள் .d.ts கோப்பின் மேலே import 'module-name'; ஐச் சேர்க்கவும்.
• முரண்பட்ட வகை வரையறைகள்: ஏற்கனவே முரண்பட்ட வகை வரையறைகளைக் கொண்ட ஒரு மாட்யூலை நீங்கள் ஆக்மென்ட் செய்தால், நீங்கள் பிழைகளைச் சந்திக்க நேரிடலாம். தற்போதுள்ள வகை வரையறைகளை கவனமாக மதிப்பாய்வு செய்து, அதற்கேற்ப உங்கள் ஆக்மென்டேஷன்களை சரிசெய்யவும்.
• தற்செயலான மேலெழுதுதல்: தற்போதுள்ள பண்புகள் அல்லது மெத்தட்களை மேலெழுதும்போது எச்சரிக்கையாக இருங்கள். உங்கள் மேலெழுதுதல்கள் அசல் வரையறைகளுடன் இணக்கமாக இருப்பதையும், அவை நூலகத்தின் செயல்பாட்டை உடைக்கவில்லை என்பதையும் உறுதிப்படுத்தவும்.
• குளோபல் மாசுபாடு: முற்றிலும் தேவைப்பட்டால் தவிர, ஒரு மாட்யூல் ஆக்மென்டேஷனுக்குள் குளோபல் மாறிகள் அல்லது வகைகளை அறிவிப்பதைத் தவிர்க்கவும். குளோபல் அறிவிப்புகள் பெயரிடும் முரண்பாடுகளுக்கு வழிவகுக்கும் மற்றும் உங்கள் குறியீட்டைப் பராமரிப்பதை கடினமாக்கும்.

மாட்யூல் ஆக்மென்டேஷனைப் பயன்படுத்துவதன் நன்மைகள்

டைப்ஸ்கிரிப்டில் மாட்யூல் ஆக்மென்டேஷனைப் பயன்படுத்துவது பல முக்கிய நன்மைகளை வழங்குகிறது:

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

முடிவுரை

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