டைப்ஸ்கிரிப்ட் மாட்யூல் ரெசல்யூஷன்: இறக்குமதி பாதை உத்திகளை எளிதாக்குதல்

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

மாட்யூல் ரெசல்யூஷன் என்றால் என்ன?

மாட்யூல் ரெசல்யூஷன் என்பது உங்கள் கோடில் உள்ள இறக்குமதி கூற்றின் அடிப்படையில் ஒரு மாட்யூலின் இருப்பிடத்தை டைப்ஸ்கிரிப்ட் கம்பைலர் தீர்மானிக்கும் செயல்முறையாகும். நீங்கள் import { SomeComponent } from './components/SomeComponent'; என்று எழுதும்போது, SomeComponent மாட்யூல் உண்மையில் உங்கள் கோப்பு அமைப்பில் எங்கு உள்ளது என்பதை டைப்ஸ்கிரிப்ட் கண்டுபிடிக்க வேண்டும். இந்த செயல்முறை, டைப்ஸ்கிரிப்ட் மாட்யூல்களைத் தேடும் விதத்தை வரையறுக்கும் விதிகள் மற்றும் உள்ளமைவுகளின் தொகுப்பால் நிர்வகிக்கப்படுகிறது.

தவறான மாட்யூல் ரெசல்யூஷன், கம்பைலேஷன் பிழைகள், ரன்டைம் பிழைகள் மற்றும் திட்டத்தின் கட்டமைப்பைப் புரிந்துகொள்வதில் சிரமத்திற்கு வழிவகுக்கும். எனவே, எந்தவொரு டைப்ஸ்கிரிப்ட் டெவலப்பருக்கும் மாட்யூல் ரெசல்யூஷன் பற்றிய திடமான புரிதல் மிக முக்கியம்.

மாட்யூல் ரெசல்யூஷன் உத்திகள்

டைப்ஸ்கிரிப்ட் இரண்டு முதன்மை மாட்யூல் ரெசல்யூஷன் உத்திகளை வழங்குகிறது, இது tsconfig.json இல் உள்ள moduleResolution கம்பைலர் விருப்பம் மூலம் கட்டமைக்கப்படுகிறது:

• கிளாசிக் (Classic): டைப்ஸ்கிரிப்ட் பயன்படுத்திய அசல் மாட்யூல் ரெசல்யூஷன் உத்தி.
• நோட் (Node): Node.js மாட்யூல் ரெசல்யூஷன் அல்காரிதத்தைப் பின்பற்றுகிறது, இது Node.js ஐ இலக்காகக் கொண்ட அல்லது npm பேக்கேஜ்களைப் பயன்படுத்தும் திட்டங்களுக்கு ஏற்றது.

கிளாசிக் மாட்யூல் ரெசல்யூஷன்

classic மாட்யூல் ரெசல்யூஷன் உத்தி இரண்டில் எளிமையானது. இது மாட்யூல்களை ஒரு நேரடியான முறையில் தேடுகிறது, இறக்குமதி செய்யும் கோப்பிலிருந்து டைரக்டரி மரத்தில் மேலே செல்கிறது.

இது எப்படி வேலை செய்கிறது:

1. இறக்குமதி செய்யும் கோப்பைக் கொண்டிருக்கும் டைரக்டரியில் இருந்து தொடங்குகிறது.
2. டைப்ஸ்கிரிப்ட் குறிப்பிட்ட பெயர் மற்றும் நீட்டிப்புகளுடன் (.ts, .tsx, .d.ts) ஒரு கோப்பைத் தேடுகிறது.
3. கண்டுபிடிக்கப்படவில்லை எனில், அது பெற்றோர் டைரக்டரிக்கு மேலே சென்று தேடலை மீண்டும் செய்கிறது.
4. மாட்யூல் கண்டுபிடிக்கப்படும் வரை அல்லது கோப்பு அமைப்பின் ரூட் அடையும் வரை இந்த செயல்முறை தொடர்கிறது.

எடுத்துக்காட்டு:

பின்வரும் திட்ட கட்டமைப்பைக் கவனியுங்கள்:

project/
├── src/
│   ├── components/
│   │   ├── SomeComponent.ts
│   │   └── index.ts
│   └── app.ts
├── tsconfig.json

app.ts கோப்பில் import { SomeComponent } from './components/SomeComponent'; என்ற இறக்குமதி அறிக்கை இருந்தால், classic மாட்யூல் ரெசல்யூஷன் உத்தி:

1. src டைரக்டரியில் ./components/SomeComponent.ts, ./components/SomeComponent.tsx, அல்லது ./components/SomeComponent.d.ts என்பதைத் தேடும்.
2. கண்டுபிடிக்கப்படவில்லை எனில், அது பெற்றோர் டைரக்டரிக்கு (திட்டத்தின் ரூட்) மேலே சென்று தேடலை மீண்டும் செய்யும், இது இந்த விஷயத்தில் வெற்றிபெற வாய்ப்பில்லை, ஏனெனில் கூறு src கோப்புறையில் உள்ளது.

வரம்புகள்:

• சிக்கலான திட்ட கட்டமைப்புகளைக் கையாள்வதில் நெகிழ்வுத்தன்மை குறைவு.
• node_modules-க்குள் தேடுவதை ஆதரிக்காது, இது npm பேக்கேஜ்களை நம்பியிருக்கும் திட்டங்களுக்குப் பொருந்தாது.
• நீளமான மற்றும் மீண்டும் மீண்டும் வரும் சார்பு இறக்குமதி பாதைகளுக்கு வழிவகுக்கும்.

எப்போது பயன்படுத்த வேண்டும்:

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

நோட் மாட்யூல் ரெசல்யூஷன்

node மாட்யூல் ரெசல்யூஷன் உத்தி Node.js பயன்படுத்தும் மாட்யூல் ரெசல்யூஷன் அல்காரிதத்தைப் பின்பற்றுகிறது. இது Node.js ஐ இலக்காகக் கொண்ட அல்லது npm பேக்கேஜ்களைப் பயன்படுத்தும் திட்டங்களுக்கு விருப்பமான தேர்வாக அமைகிறது, ஏனெனில் இது நிலையான மற்றும் கணிக்கக்கூடிய மாட்யூல் ரெசல்யூஷன் நடத்தையை வழங்குகிறது.

இது எப்படி வேலை செய்கிறது:

node மாட்யூல் ரெசல்யூஷன் உத்தி ஒரு சிக்கலான விதிகளைப் பின்பற்றுகிறது, node_modules-க்குள் தேடுவதற்கு முன்னுரிமை அளிக்கிறது மற்றும் வெவ்வேறு கோப்பு நீட்டிப்புகளைக் கையாளுகிறது:

1. சார்பு இல்லாத இறக்குமதிகள்: இறக்குமதி பாதை ./, ../, அல்லது / உடன் தொடங்கவில்லை என்றால், டைப்ஸ்கிரிப்ட் அதை node_modules-இல் அமைந்துள்ள ஒரு மாட்யூல் என்று கருதுகிறது. அது பின்வரும் இடங்களில் மாட்யூலைத் தேடும்:
• தற்போதைய டைரக்டரியில் உள்ள node_modules.
• பெற்றோர் டைரக்டரியில் உள்ள node_modules.
• ... மற்றும் கோப்பு அமைப்பின் ரூட் வரை தொடரும்.
2. சார்பு இறக்குமதிகள்: இறக்குமதி பாதை ./, ../, அல்லது / உடன் தொடங்கினால், டைப்ஸ்கிரிப்ட் அதை ஒரு சார்பு பாதையாகக் கருதி, குறிப்பிட்ட இடத்தில் மாட்யூலைத் தேடுகிறது, பின்வருவனவற்றைக் கருத்தில் கொண்டு:
• முதலில் குறிப்பிட்ட பெயர் மற்றும் நீட்டிப்புகளுடன் (.ts, .tsx, .d.ts) ஒரு கோப்பைத் தேடும்.
• கண்டுபிடிக்கப்படவில்லை எனில், அது குறிப்பிட்ட பெயரில் ஒரு டைரக்டரியையும், அந்த டைரக்டரிக்குள் index.ts, index.tsx, அல்லது index.d.ts என்ற கோப்பையும் தேடும் (எ.கா., இறக்குமதி ./components எனில் ./components/index.ts).

எடுத்துக்காட்டு:

lodash நூலகத்தைச் சார்ந்திருக்கும் பின்வரும் திட்ட கட்டமைப்பைக் கவனியுங்கள்:

project/
├── src/
│   ├── utils/
│   │   └── helpers.ts
│   └── app.ts
├── node_modules/
│   └── lodash/
│       └── lodash.js
├── tsconfig.json

app.ts கோப்பில் import * as _ from 'lodash'; என்ற இறக்குமதி அறிக்கை இருந்தால், node மாட்யூல் ரெசல்யூஷன் உத்தி:

1. lodash ஒரு சார்பு இல்லாத இறக்குமதி என்பதை அங்கீகரிக்கும்.
2. திட்டத்தின் ரூட்டில் உள்ள node_modules டைரக்டரியில் lodash-ஐத் தேடும்.
3. node_modules/lodash/lodash.js-இல் lodash மாட்யூலைக் கண்டுபிடிக்கும்.

helpers.ts கோப்பில் import { SomeHelper } from './SomeHelper'; என்ற இறக்குமதி அறிக்கை இருந்தால், node மாட்யூல் ரெசல்யூஷன் உத்தி:

1. ./SomeHelper ஒரு சார்பு இறக்குமதி என்பதை அங்கீகரிக்கும்.
2. src/utils டைரக்டரியில் ./SomeHelper.ts, ./SomeHelper.tsx, அல்லது ./SomeHelper.d.ts-ஐத் தேடும்.
3. அந்த கோப்புகள் எதுவும் இல்லை என்றால், அது SomeHelper என்ற டைரக்டரியைத் தேடி, பின்னர் அந்த டைரக்டரிக்குள் index.ts, index.tsx, அல்லது index.d.ts-ஐத் தேடும்.

நன்மைகள்:

• node_modules மற்றும் npm பேக்கேஜ்களை ஆதரிக்கிறது.
• Node.js உடன் நிலையான மாட்யூல் ரெசல்யூஷன் நடத்தையை வழங்குகிறது.
• node_modules-இல் உள்ள மாட்யூல்களுக்கு சார்பு இல்லாத இறக்குமதிகளை அனுமதிப்பதன் மூலம் இறக்குமதி பாதைகளை எளிதாக்குகிறது.

எப்போது பயன்படுத்த வேண்டும்:

node மாட்யூல் ரெசல்யூஷன் உத்தி பெரும்பாலான டைப்ஸ்கிரிப்ட் திட்டங்களுக்கு, குறிப்பாக Node.js ஐ இலக்காகக் கொண்ட அல்லது npm பேக்கேஜ்களைப் பயன்படுத்தும் திட்டங்களுக்குப் பரிந்துரைக்கப்படுகிறது. இது classic உத்தியை விட மிகவும் நெகிழ்வான மற்றும் வலுவான மாட்யூல் ரெசல்யூஷன் அமைப்பை வழங்குகிறது.

tsconfig.json-இல் மாட்யூல் ரெசல்யூஷனை உள்ளமைத்தல்

tsconfig.json கோப்பு உங்கள் டைப்ஸ்கிரிப்ட் திட்டத்திற்கான மைய உள்ளமைவு கோப்பாகும். இது மாட்யூல் ரெசல்யூஷன் உத்தி உட்பட கம்பைலர் விருப்பங்களைக் குறிப்பிடவும், டைப்ஸ்கிரிப்ட் உங்கள் கோடை எவ்வாறு கையாளுகிறது என்பதைத் தனிப்பயனாக்கவும் உங்களை அனுமதிக்கிறது.

node மாட்யூல் ரெசல்யூஷன் உத்தியுடன் ஒரு அடிப்படை tsconfig.json கோப்பு இங்கே உள்ளது:

{
  "compilerOptions": {
    "moduleResolution": "node",
    "target": "es5",
    "module": "commonjs",
    "esModuleInterop": true,
    "strict": true,
    "outDir": "dist",
    "sourceMap": true
  },
  "include": [
    "src/**/*"
  ],
  "exclude": [
    "node_modules"
  ]
}

மாட்யூல் ரெசல்யூஷன் தொடர்பான முக்கிய compilerOptions:

• moduleResolution: மாட்யூல் ரெசல்யூஷன் உத்தியைக் குறிப்பிடுகிறது (classic அல்லது node).
• baseUrl: சார்பு இல்லாத மாட்யூல் பெயர்களைத் தீர்ப்பதற்கான அடிப்படை டைரக்டரியைக் குறிப்பிடுகிறது.
• paths: மாட்யூல்களுக்கு தனிப்பயன் பாதை மேப்பிங்குகளை உள்ளமைக்க உங்களை அனுமதிக்கிறது.

baseUrl மற்றும் paths: இறக்குமதி பாதைகளைக் கட்டுப்படுத்துதல்

baseUrl மற்றும் paths கம்பைலர் விருப்பங்கள் டைப்ஸ்கிரிப்ட் இறக்குமதி பாதைகளை எவ்வாறு தீர்க்கிறது என்பதைக் கட்டுப்படுத்த சக்திவாய்ந்த வழிமுறைகளை வழங்குகின்றன. முழுமையான இறக்குமதிகளைப் பயன்படுத்தவும் மற்றும் தனிப்பயன் பாதை மேப்பிங்குகளை உருவாக்கவும் அனுமதிப்பதன் மூலம் அவை உங்கள் கோடின் வாசிப்புத்திறனையும் பராமரிப்பையும் கணிசமாக மேம்படுத்த முடியும்.

baseUrl

baseUrl விருப்பம் சார்பு இல்லாத மாட்யூல் பெயர்களைத் தீர்ப்பதற்கான அடிப்படை டைரக்டரியைக் குறிப்பிடுகிறது. baseUrl அமைக்கப்படும்போது, டைப்ஸ்கிரிப்ட் தற்போதைய வேலை செய்யும் டைரக்டரிக்கு பதிலாக குறிப்பிட்ட அடிப்படை டைரக்டரிக்கு சார்பாக சார்பு இல்லாத இறக்குமதி பாதைகளைத் தீர்க்கும்.

எடுத்துக்காட்டு:

பின்வரும் திட்ட கட்டமைப்பைக் கவனியுங்கள்:

project/
├── src/
│   ├── components/
│   │   ├── SomeComponent.ts
│   │   └── index.ts
│   └── app.ts
├── tsconfig.json

tsconfig.json பின்வருவனவற்றைக் கொண்டிருந்தால்:

{
  "compilerOptions": {
    "moduleResolution": "node",
    "baseUrl": "./src"
  }
}

பின்னர், app.ts-இல், நீங்கள் பின்வரும் இறக்குமதி கூற்றைப் பயன்படுத்தலாம்:

import { SomeComponent } from 'components/SomeComponent';

இதற்கு பதிலாக:

import { SomeComponent } from './components/SomeComponent';

டைப்ஸ்கிரிப்ட் baseUrl ஆல் குறிப்பிடப்பட்ட ./src டைரக்டரிக்கு சார்பாக components/SomeComponent-ஐத் தீர்க்கும்.

baseUrl பயன்படுத்துவதன் நன்மைகள்:

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

paths

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

paths விருப்பம் ஒரு பொருளாகும், அங்கு ஒவ்வொரு திறவுச்சொல்லும் ஒரு பாதை வடிவத்தைக் குறிக்கிறது, மேலும் ஒவ்வொரு மதிப்பும் பாதை மாற்றீடுகளின் வரிசையாகும். டைப்ஸ்கிரிப்ட் இறக்குமதி பாதையை பாதை வடிவங்களுடன் பொருத்த முயற்சிக்கும், ஒரு பொருத்தம் காணப்பட்டால், இறக்குமதி பாதையை குறிப்பிட்ட மாற்றுப் பாதைகளுடன் மாற்றும்.

எடுத்துக்காட்டு:

பின்வரும் திட்ட கட்டமைப்பைக் கவனியுங்கள்:

project/
├── src/
│   ├── components/
│   │   ├── SomeComponent.ts
│   │   └── index.ts
│   └── app.ts
├── libs/
│   └── my-library.ts
├── tsconfig.json

tsconfig.json பின்வருவனவற்றைக் கொண்டிருந்தால்:

{
  "compilerOptions": {
    "moduleResolution": "node",
    "baseUrl": "./src",
    "paths": {
      "@components/*": ["components/*"],
      "@mylib": ["../libs/my-library.ts"]
    }
  }
}

பின்னர், app.ts-இல், நீங்கள் பின்வரும் இறக்குமதி கூற்றுகளைப் பயன்படுத்தலாம்:

import { SomeComponent } from '@components/SomeComponent';
import { MyLibraryFunction } from '@mylib';

டைப்ஸ்கிரிப்ட் @components/* பாதை மேப்பிங்கின் அடிப்படையில் @components/SomeComponent-ஐ components/SomeComponent-ஆகவும், @mylib பாதை மேப்பிங்கின் அடிப்படையில் @mylib-ஐ ../libs/my-library.ts-ஆகவும் தீர்க்கும்.

paths பயன்படுத்துவதன் நன்மைகள்:

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

paths-க்கான பொதுவான பயன்பாட்டு வழக்குகள்:

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

இறக்குமதி பாதைகளை நிர்வகிப்பதற்கான சிறந்த நடைமுறைகள்

அளவிடக்கூடிய மற்றும் பராமரிக்கக்கூடிய டைப்ஸ்கிரிப்ட் பயன்பாடுகளை உருவாக்குவதற்கு இறக்குமதி பாதைகளின் திறமையான மேலாண்மை மிக முக்கியம். பின்பற்ற வேண்டிய சில சிறந்த நடைமுறைகள் இங்கே:

• node மாட்யூல் ரெசல்யூஷன் உத்தியைப் பயன்படுத்தவும்: node மாட்யூல் ரெசல்யூஷன் உத்தி பெரும்பாலான டைப்ஸ்கிரிப்ட் திட்டங்களுக்குப் பரிந்துரைக்கப்பட்ட தேர்வாகும், ஏனெனில் இது நிலையான மற்றும் கணிக்கக்கூடிய மாட்யூல் ரெசல்யூஷன் நடத்தையை வழங்குகிறது.
• baseUrl-ஐ உள்ளமைக்கவும்: இறக்குமதி பாதைகளை எளிதாக்கவும் மற்றும் வாசிப்புத்திறனை மேம்படுத்தவும் உங்கள் மூலக் கோட்டின் ரூட் டைரக்டரிக்கு baseUrl விருப்பத்தை அமைக்கவும்.
• தனிப்பயன் பாதை மேப்பிங்குகளுக்கு paths-ஐப் பயன்படுத்தவும்: மாட்யூல்களுக்கு மாற்றுப்பெயர்களை உருவாக்கவும் மற்றும் இறக்குமதிகளை வெவ்வேறு இடங்களுக்கு திருப்பி விடவும் paths விருப்பத்தைப் பயன்படுத்தவும், இயற்பியல் கோப்பு கட்டமைப்பை இறக்குமதி பாதைகளிலிருந்து பிரித்தெடுக்கவும்.
• ஆழமாக உள்ளமைக்கப்பட்ட சார்பு இறக்குமதி பாதைகளைத் தவிர்க்கவும்: ஆழமாக உள்ளமைக்கப்பட்ட சார்பு இறக்குமதி பாதைகள் (எ.கா., ../../../../utils/helpers) படிக்கவும் பராமரிக்கவும் கடினமாக இருக்கும். இந்தப் பாதைகளை எளிதாக்க baseUrl மற்றும் paths-ஐப் பயன்படுத்தவும்.
• உங்கள் இறக்குமதி பாணியில் சீராக இருங்கள்: ஒரு நிலையான இறக்குமதி பாணியைத் தேர்வுசெய்து (எ.கா., முழுமையான இறக்குமதிகள் அல்லது சார்பு இறக்குமதிகளைப் பயன்படுத்துதல்) உங்கள் திட்டம் முழுவதும் அதைப் பின்பற்றவும்.
• உங்கள் கோடை நன்கு வரையறுக்கப்பட்ட மாட்யூல்களாக ஒழுங்கமைக்கவும்: உங்கள் கோடை நன்கு வரையறுக்கப்பட்ட மாட்யூல்களாக ஒழுங்கமைப்பது புரிந்துகொள்வதையும் பராமரிப்பதையும் எளிதாக்குகிறது, மேலும் இறக்குமதி பாதைகளை நிர்வகிக்கும் செயல்முறையை எளிதாக்குகிறது.
• ஒரு கோட் ஃபார்மேட்டர் மற்றும் லின்டரைப் பயன்படுத்தவும்: ஒரு கோட் ஃபார்மேட்டர் மற்றும் லின்டர் நிலையான குறியீட்டுத் தரங்களைச் செயல்படுத்தவும் மற்றும் உங்கள் இறக்குமதி பாதைகளில் உள்ள சாத்தியமான சிக்கல்களை அடையாளம் காணவும் உதவும்.

மாட்யூல் ரெசல்யூஷன் சிக்கல்களை சரிசெய்தல்

மாட்யூல் ரெசல்யூஷன் சிக்கல்கள் பிழைத்திருத்தம் செய்வது வெறுப்பாக இருக்கலாம். இங்கே சில பொதுவான சிக்கல்கள் மற்றும் தீர்வுகள் உள்ளன:

• "Cannot find module" பிழை:
  • சிக்கல்: டைப்ஸ்கிரிப்ட்டால் குறிப்பிட்ட மாட்யூலைக் கண்டுபிடிக்க முடியவில்லை.
  • தீர்வு:
    • மாட்யூல் நிறுவப்பட்டுள்ளதா என்பதைச் சரிபார்க்கவும் (அது ஒரு npm பேக்கேஜ் என்றால்).
    • இறக்குமதி பாதையில் எழுத்துப்பிழைகளைச் சரிபார்க்கவும்.
    • tsconfig.json-இல் moduleResolution, baseUrl, மற்றும் paths விருப்பங்கள் சரியாக உள்ளமைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்.
    • எதிர்பார்க்கப்படும் இடத்தில் மாட்யூல் கோப்பு உள்ளதா என்பதை உறுதிப்படுத்தவும்.
• தவறான மாட்யூல் பதிப்பு:
  • சிக்கல்: நீங்கள் ஒரு பொருந்தாத பதிப்புடன் ஒரு மாட்யூலை இறக்குமதி செய்கிறீர்கள்.
  • தீர்வு:
    • மாட்யூலின் எந்தப் பதிப்பு நிறுவப்பட்டுள்ளது என்பதைப் பார்க்க உங்கள் package.json கோப்பைச் சரிபார்க்கவும்.
    • மாட்யூலை ஒரு இணக்கமான பதிப்பிற்குப் புதுப்பிக்கவும்.
• சுழற்சி சார்புகள்:
  • சிக்கல்: இரண்டு அல்லது அதற்கு மேற்பட்ட மாட்யூல்கள் ஒன்றையொன்று சார்ந்து, ஒரு சுழற்சி சார்பை உருவாக்குகின்றன.
  • தீர்வு:
    • சுழற்சி சார்பை உடைக்க உங்கள் கோடை மறுசீரமைக்கவும்.
    • மாட்யூல்களைத் துண்டிக்க சார்பு உட்செலுத்தலைப் பயன்படுத்தவும்.

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

டைப்ஸ்கிரிப்ட் மாட்யூல் ரெசல்யூஷனின் கொள்கைகள் பல்வேறு ஜாவாஸ்கிரிப்ட் கட்டமைப்புகளில் பொருந்தும். அவை பொதுவாக எவ்வாறு பயன்படுத்தப்படுகின்றன என்பது இங்கே:

• React:
  • ரியாக்ட் திட்டங்கள் கூறு-அடிப்படையிலான கட்டமைப்பை பெரிதும் நம்பியுள்ளன, சரியான மாட்யூல் ரெசல்யூஷனை முக்கியமானதாக ஆக்குகிறது.
  • baseUrl-ஐ src டைரக்டரியைக் குறிக்கப் பயன்படுத்துவது import MyComponent from 'components/MyComponent'; போன்ற சுத்தமான இறக்குமதிகளை செயல்படுத்துகிறது.
  • styled-components அல்லது material-ui போன்ற நூலகங்கள் பொதுவாக node ரெசல்யூஷன் உத்தியைப் பயன்படுத்தி node_modules-இலிருந்து நேரடியாக இறக்குமதி செய்யப்படுகின்றன.
• Angular:
  • ஆங்குலர் CLI baseUrl மற்றும் paths உட்பட புத்திசாலித்தனமான இயல்புநிலைகளுடன் tsconfig.json-ஐ தானாகவே உள்ளமைக்கிறது.
  • ஆங்குலர் மாட்யூல்கள் மற்றும் கூறுகள் பெரும்பாலும் அம்ச மாட்யூல்களாக ஒழுங்கமைக்கப்படுகின்றன, மாட்யூல்களுக்குள் மற்றும் இடையில் எளிமைப்படுத்தப்பட்ட இறக்குமதிகளுக்கு பாதை மாற்றுப்பெயர்களைப் பயன்படுத்துகின்றன. உதாரணமாக, @app/shared ஒரு பகிரப்பட்ட மாட்யூல் டைரக்டரிக்கு மேப் செய்யப்படலாம்.
• Vue.js:
  • ரியாக்ட்டைப் போலவே, Vue.js திட்டங்களும் கூறு இறக்குமதிகளை நெறிப்படுத்த baseUrl-ஐப் பயன்படுத்துவதன் மூலம் பயனடைகின்றன.
  • Vuex ஸ்டோர் மாட்யூல்களை paths-ஐப் பயன்படுத்தி எளிதாக மாற்றுப்பெயர் இடலாம், கோட்பேஸின் அமைப்பு மற்றும் வாசிப்புத்திறனை மேம்படுத்துகிறது.
• Node.js (Express, NestJS):
  • NestJS, எடுத்துக்காட்டாக, ஒரு கட்டமைக்கப்பட்ட பயன்பாட்டில் மாட்யூல் இறக்குமதிகளை நிர்வகிக்க பாதை மாற்றுப்பெயர்களை விரிவாகப் பயன்படுத்த ஊக்குவிக்கிறது.
  • node மாட்யூல் ரெசல்யூஷன் உத்தி இயல்புநிலையாகவும் node_modules உடன் வேலை செய்வதற்கு அவசியமானதாகவும் உள்ளது.

முடிவுரை

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