டைப்ஸ்கிரிப்ட் இறக்குமதி வகை: வகை-மட்டும் இறக்குமதி அறிவிப்புகளின் ஆழமான பார்வை

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

import type என்றால் என்ன?

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

import type ஐ ஏன் பயன்படுத்த வேண்டும்?

import type ஐப் பயன்படுத்த பல బలமான காரணங்கள் உள்ளன:

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

import type ஐப் பயன்படுத்துவது எப்படி

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

import type { User } from './user';

function greetUser(user: User): string {
  return `Hello, ${user.name}!`;
}

இந்த எடுத்துக்காட்டில், நாம் ./user தொகுதியிலிருந்து User வகையை இறக்குமதி செய்கிறோம். நாம் greetUser செயல்பாட்டில் வகை குறிப்பிற்காக மட்டுமே User வகையைப் பயன்படுத்துகிறோம். User தொகுதியின் மதிப்புகள் இயக்க நேரத்தில் அணுக முடியாதவை.

import type ஐ வழக்கமான இறக்குமதிகளுடன் இணைத்தல்

type என்ற முக்கிய சொல்லைப் பயன்படுத்தி ஒரே கூற்றில் import type ஐ வழக்கமான இறக்குமதிகளுடன் இணைக்கலாம்:

import { someValue, type User, type Product } from './module';

function processUser(user: User): void {
  // ...
}

console.log(someValue);

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

அனைத்தையும் வகைகளாக இறக்குமதி செய்தல்

நீங்கள் ஒரு தொகுதியிலிருந்து மதிப்புகள் எதையும் இறக்குமதி செய்யாமல் அனைத்து வகைகளையும் இறக்குமதி செய்ய வேண்டுமானால், நீங்கள் namespace இறக்குமதி தொடரியலைப் பயன்படுத்தலாம் import type உடன்:

import type * as Types from './types';

function processData(data: Types.Data): void {
  // ...
}

இங்கே, நாம் ./types தொகுதியிலிருந்து அனைத்து வகைகளையும் Types namespace இல் இறக்குமதி செய்கிறோம். பின்னர் நாம் Types. முன்னொட்டைப் பயன்படுத்தி வகைகளை அணுகலாம்.

பல்வேறு திட்ட வகைகளில் எடுத்துக்காட்டுகள்

`import type`-இன் நன்மைகள் பல்வேறு திட்ட வகைகளுக்குப் பொருந்தும். இதோ சில எடுத்துக்காட்டுகள்:

எடுத்துக்காட்டு 1: ரியாக்ட் கூறு (Component)

குறிப்பிட்ட வகைகளைக் கொண்ட props-ஐப் பெறும் ஒரு ரியாக்ட் கூறைக் கருத்தில் கொள்ளுங்கள்:

import React from 'react';
import type { User } from './user';

interface Props {
  user: User;
}

const UserProfile: React.FC<Props> = ({ user }) => {
  return (
    <div>
      <h2>User Profile</h2>
      <p>Name: {user.name}</p>
      <p>Email: {user.email}</p>
    </div>
  );
};

export default UserProfile;

இந்த ரியாக்ட் எடுத்துக்காட்டில், `import type { User } from './user';` என்பது `User`-இன் வகை வரையறை மட்டுமே இறக்குமதி செய்யப்படுவதை உறுதிசெய்கிறது, இது தொகுப்பு அளவை மேம்படுத்துகிறது. நாம் 'user' தொகுதியின் மதிப்புகளை நேரடியாகப் பயன்படுத்தவில்லை; அந்த தொகுதியில் வரையறுக்கப்பட்டுள்ள 'User' *வகையை* மட்டுமே பயன்படுத்துகிறோம்.

எடுத்துக்காட்டு 2: Node.js பின்தளம் (Backend)

ஒரு Node.js பின்தள பயன்பாட்டில், நீங்கள் தரவுத்தள மாதிரிகளை வகைகளாக வரையறுக்கலாம்:

import type { User } from './models';
import { createUser } from './db';

async function registerUser(userData: User): Promise<void> {
  await createUser(userData);
}

இங்கே, `import type { User } from './models';` என்பது `User` வகை மட்டுமே வகை சரிபார்ப்புக்கு தேவைப்பட்டால், முழு `models` தொகுதியையும் தொகுப்பில் சேர்ப்பதைத் தவிர்க்கிறது. `createUser` செயல்பாடு *இயக்க நேர* பயன்பாட்டிற்குத் தேவைப்படுவதால் அது இறக்குமதி செய்யப்படுகிறது.

எடுத்துக்காட்டு 3: ஆங்குலர் சேவை (Service)

ஒரு ஆங்குலர் சேவையில், ஒரு வகையைப் பயன்படுத்தும் ஒரு சேவையை நீங்கள் செலுத்தலாம் (inject):

import { Injectable } from '@angular/core';
import type { Product } from './product.model';
import { ProductService } from './product.service';

@Injectable({
  providedIn: 'root',
})
export class OrderService {
  constructor(private productService: ProductService) {}

  getFeaturedProducts(): Product[] {
    return this.productService.getProducts().filter(p => p.isFeatured);
  }
}

`Product` வகை என்பது `productService.getProducts()` முறை மூலம் திருப்பியளிக்கப்படும் தரவின் கட்டமைப்பை வரையறுக்கப் பயன்படுகிறது. `import type { Product } from './product.model';` ஐப் பயன்படுத்துவது, வகை தகவல் மட்டுமே இறக்குமதி செய்யப்படுவதை உறுதிசெய்கிறது, இது ஆங்குலர் பயன்பாட்டின் செயல்திறனை மேம்படுத்துகிறது. `ProductService` என்பது ஒரு *இயக்க நேர* சார்பு ஆகும்.

பல்வேறு மேம்பாட்டு சூழல்களில் import type ஐப் பயன்படுத்துவதன் நன்மைகள்

import type ஐப் பயன்படுத்துவதன் நன்மைகள் பல்வேறு மேம்பாட்டு அமைப்புகளில் பரவியுள்ளன:

• மோனோரெப்போஸ்: மோனோரெப்போ கட்டமைப்புகளுக்குள், import type தனிப்பட்ட தொகுப்பு தொகுப்புகளின் அளவைக் குறைக்கிறது, இது வேகமான உருவாக்க நேரங்களுக்கும் திறமையான வள பயன்பாட்டிற்கும் வழிவகுக்கிறது.
• மைக்ரோசர்வீசஸ்: மைக்ரோசர்வீசஸ் கட்டமைப்பில், import type சார்பு நிர்வாகத்தை எளிதாக்குகிறது மற்றும் தேவையான வகை தகவல்கள் மட்டுமே இறக்குமதி செய்யப்படுவதை உறுதி செய்வதன் மூலம் சேவைகளின் மட்டுப்படுத்தலை மேம்படுத்துகிறது.
• சர்வர்லெஸ் செயல்பாடுகள்: சர்வர்லெஸ் செயல்பாட்டு சூழல்களில், import type செயல்பாட்டு வரிசைப்படுத்தல் தொகுப்பு அளவுகளைக் குறைக்கிறது, இதன் விளைவாக விரைவான குளிர் தொடக்கங்கள் (cold starts) மற்றும் உகந்த வள நுகர்வு ஏற்படுகிறது.
• குறுக்கு-தள மேம்பாடு: வலை, மொபைல் அல்லது டெஸ்க்டாப் தளங்களுக்காக உருவாக்கும் போது, import type வெவ்வேறு சூழல்களில் சீரான வகை சரிபார்ப்பை உறுதி செய்கிறது மற்றும் இயக்க நேரப் பிழைகளின் வாய்ப்பைக் குறைக்கிறது.

சாத்தியமான எச்சரிக்கைகள்

import type பொதுவாக நன்மை பயக்கும் என்றாலும், கவனத்தில் கொள்ள வேண்டிய சில எச்சரிக்கைகள் உள்ளன:

• டைப்ஸ்கிரிப்ட் பதிப்பு தேவை: import type டைப்ஸ்கிரிப்ட் 3.8 இல் அறிமுகப்படுத்தப்பட்டது. இந்த தொடரியலைப் பயன்படுத்த நீங்கள் குறைந்தபட்சம் இந்த டைப்ஸ்கிரிப்ட் பதிப்பைப் பயன்படுத்த வேண்டும்.
• இயக்க நேர பயன்பாடு: நீங்கள் import type மூலம் இறக்குமதி செய்யப்பட்ட ஒரு மதிப்பை இயக்க நேரத்தில் பயன்படுத்த முடியாது. நீங்கள் இயக்க நேரத்தில் ஒரு தொகுதியிலிருந்து ஒரு மதிப்பை அணுக வேண்டுமானால், நீங்கள் ஒரு வழக்கமான import கூற்றைப் பயன்படுத்த வேண்டும். import type மூலம் இறக்குமதி செய்யப்பட்ட மதிப்பை இயக்க நேரத்தில் பயன்படுத்த முயற்சித்தால், அது தொகுப்பு நேரப் பிழைக்கு (compile-time error) வழிவகுக்கும்.
• டிரான்ஸ்பைலர்கள் மற்றும் பண்ட்லர்கள்: உங்கள் டிரான்ஸ்பைலர் (எ.கா., பேபல்) மற்றும் பண்ட்லர் (எ.கா., வெப்பேக், ரோலப், பார்சல்) ஆகியவை import type கூற்றுகளை சரியாகக் கையாளும்படி கட்டமைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். பெரும்பாலான நவீன கருவிகள் import type ஐ தானாகவே ஆதரிக்கின்றன, ஆனால் உங்கள் உள்ளமைவை இருமுறை சரிபார்ப்பது எப்போதும் ஒரு நல்ல யோசனையாகும். சில பழைய கருவிகளுக்கு இந்த இறக்குமதிகளை சரியாக அகற்ற குறிப்பிட்ட செருகுநிரல்கள் அல்லது உள்ளமைவுகள் தேவைப்படலாம்.

import type ஐப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

import type ஐ திறம்பட பயன்படுத்த, பின்வரும் சிறந்த நடைமுறைகளைக் கருத்தில் கொள்ளுங்கள்:

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

சர்வதேசமயமாக்கல் (i18n) மற்றும் உள்ளூர்மயமாக்கல் (l10n) கருத்தாய்வுகள்

சர்வதேசமயமாக்கல் (i18n) மற்றும் உள்ளூர்மயமாக்கல் (l10n) தேவைப்படும் திட்டங்களில் பணிபுரியும்போது, import type உங்கள் குறியீட்டை எவ்வாறு பாதிக்கலாம் என்பதைக் கருத்தில் கொள்வது அவசியம். மனதில் கொள்ள வேண்டிய சில குறிப்புகள் இங்கே:

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

பல்வேறு நாடுகளில் உள்ள எடுத்துக்காட்டுகள்

பல்வேறு நாடுகளில் உள்ள பல்வேறு சூழ்நிலைகளில் import type எவ்வாறு பயன்படுத்தப்படலாம் என்பதை விளக்கும் சில எடுத்துக்காட்டுகள் இங்கே:

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

  import type { Product } from './product.types';
  
    function displayProductDetails(product: Product) {
      // ...
    }

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

  import type { Patient } from './patient.types';
  
    function anonymizePatientData(patient: Patient) {
      // ...
    }

• கல்வித் தளம் (ஜப்பான்): ஜப்பானில் உள்ள ஒரு கல்வித் தளம், பாடப் பொருள் வகைகளை வரையறுக்க `import type` ஐப் பயன்படுத்துகிறது. இது தளத்தின் செயல்திறனை மேம்படுத்த உதவுகிறது, குறிப்பாக அதிக அளவிலான உள்ளடக்கத்தைக் கையாளும்போது.

  import type { CourseMaterial } from './course.types';
  
     function renderCourseMaterial(material: CourseMaterial) {
      // ...
     }

• நிதிச் சேவைப் பயன்பாடு (பிரேசில்): பிரேசிலில் உள்ள ஒரு நிதிச் சேவைப் பயன்பாடு, பரிவர்த்தனை வகைகளை வரையறுக்க `import type` ஐப் பயன்படுத்துகிறது. இது தரவு நிலைத்தன்மையை உறுதி செய்வதன் மூலமும், தொகுப்பு அளவைக் குறைப்பதன் மூலமும் பயன்பாட்டின் செயல்திறனையும் நம்பகத்தன்மையையும் மேம்படுத்துகிறது.

  import type { Transaction } from './transaction.types';
  
    function processTransaction(transaction: Transaction) {
     // ...
    }

முடிவுரை

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