ടൈപ്പ്സ്ക്രിപ്റ്റ് പെർഫോമൻസ്: കംപൈലേഷൻ വേഗത ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകൾ

ജാവാസ്ക്രിപ്റ്റിൻ്റെ ഒരു സൂപ്പർസെറ്റായ ടൈപ്പ്സ്ക്രിപ്റ്റ്, സ്റ്റാറ്റിക് ടൈപ്പിംഗ്, മെച്ചപ്പെട്ട കോഡ് ഓർഗനൈസേഷൻ, മെച്ചപ്പെട്ട മെയിൻ്റനബിലിറ്റി എന്നിവ നൽകുന്നു. എന്നിരുന്നാലും, പ്രോജക്റ്റുകൾ വലുപ്പത്തിലും സങ്കീർണ്ണതയിലും വളരുമ്പോൾ, ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലേഷൻ ഡെവലപ്മെൻ്റ് വർക്ക്ഫ്ലോയിലെ ഒരു പ്രധാന തടസ്സമായി മാറും. കുറഞ്ഞ കംപൈലേഷൻ സമയം ഡെവലപ്പർമാരുടെ ഉത്പാദനക്ഷമത കുറയ്ക്കുന്നതിനും, നിരാശ വർദ്ധിപ്പിക്കുന്നതിനും, ദൈർഘ്യമേറിയ ഇറ്ററേഷൻ സൈക്കിളുകൾക്കും കാരണമാകും. ഈ ലേഖനം ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലേഷൻ വേഗത ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിനുള്ള ഫലപ്രദമായ ടെക്നിക്കുകളിലേക്ക് കടന്നുചെല്ലുന്നു, ഇത് സുഗമവും കാര്യക്ഷമവുമായ ഒരു ഡെവലപ്മെൻ്റ് അനുഭവം ഉറപ്പാക്കുന്നു.

കംപൈലേഷൻ പ്രക്രിയ മനസ്സിലാക്കുന്നു

ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകളിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലേഷൻ പ്രക്രിയ മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ (tsc) ടൈപ്പ്സ്ക്രിപ്റ്റ് ഫയലുകൾ വായിക്കുകയും, ടൈപ്പ് ചെക്കിംഗ് നടത്തുകയും, ജാവാസ്ക്രിപ്റ്റ് ഫയലുകൾ പുറത്തുവിടുകയും ചെയ്യുന്നു. കംപൈലേഷൻ വേഗതയെ സ്വാധീനിക്കുന്ന നിരവധി ഘടകങ്ങളുണ്ട്, അവയിൽ ഉൾപ്പെടുന്നവ:

• പ്രോജക്റ്റിൻ്റെ വലുപ്പം: ടൈപ്പ്സ്ക്രിപ്റ്റ് ഫയലുകളുടെയും കോഡ് ലൈനുകളുടെയും എണ്ണം കംപൈലേഷൻ സമയത്തെ നേരിട്ട് ബാധിക്കുന്നു.
• ടൈപ്പ് സങ്കീർണ്ണത: സങ്കീർണ്ണമായ ടൈപ്പ് ഡെഫനിഷനുകൾ, ജെനറിക്കുകൾ, യൂണിയനുകൾ എന്നിവ കംപൈലറിൻ്റെ ജോലിഭാരം വർദ്ധിപ്പിക്കുന്നു.
• മൊഡ്യൂൾ റെസൊല്യൂഷൻ: മൊഡ്യൂൾ ഡിപൻഡൻസികൾ കണ്ടെത്തുന്നതിനും പരിഹരിക്കുന്നതിനുമുള്ള പ്രക്രിയ സമയമെടുക്കുന്ന ഒന്നാണ്, പ്രത്യേകിച്ചും സങ്കീർണ്ണമായ മൊഡ്യൂൾ ഘടനകളുള്ള വലിയ പ്രോജക്റ്റുകളിൽ.
• tsconfig.json കോൺഫിഗറേഷൻ: tsconfig.json ഫയലിൽ വ്യക്തമാക്കിയ കംപൈലർ ഓപ്ഷനുകൾ കംപൈലേഷൻ വേഗതയെയും ഔട്ട്‌പുട്ടിനെയും കാര്യമായി ബാധിക്കുന്നു.
• ഹാർഡ്‌വെയർ: സിപിയു വേഗത, റാം, ഡിസ്ക് I/O പ്രകടനം എന്നിവയും ഒരു പങ്ക് വഹിക്കുന്നു.

ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകൾ

ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലേഷൻ വേഗത ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിനുള്ള ചില ടെക്നിക്കുകൾ താഴെ നൽകുന്നു:

1. ഇൻക്രിമെൻ്റൽ കംപൈലേഷൻ

കംപൈലേഷൻ വേഗത മെച്ചപ്പെടുത്തുന്നതിനുള്ള ഏറ്റവും ഫലപ്രദമായ മാർഗ്ഗങ്ങളിലൊന്നാണ് ഇൻക്രിമെൻ്റൽ കംപൈലേഷൻ. ഇത് പ്രവർത്തനക്ഷമമാക്കുമ്പോൾ, കംപൈലർ പ്രോജക്റ്റിൻ്റെ ഘടനയെയും ഡിപൻഡൻസികളെയും കുറിച്ചുള്ള വിവരങ്ങൾ കാഷെ ചെയ്യുന്നു. തുടർന്നുള്ള കംപൈലേഷനുകൾ അവസാന കംപൈലേഷനുശേഷം മാറ്റം വരുത്തിയ ഫയലുകൾ മാത്രം പ്രോസസ്സ് ചെയ്യുന്നു. ഇൻക്രിമെൻ്റൽ കംപൈലേഷൻ പ്രവർത്തനക്ഷമമാക്കാൻ, നിങ്ങളുടെ tsconfig.json ഫയലിൽ incremental ഓപ്ഷൻ true ആയി സജ്ജമാക്കുക:

            {
  "compilerOptions": {
    "incremental": true,
    "tsBuildInfoFile": ".tsbuildinfo" // Optional, but recommended
  }
}
            

              
                Copy
              
            
          

tsBuildInfoFile ഓപ്ഷൻ ഇൻക്രിമെൻ്റൽ ബിൽഡ് ഇൻഫർമേഷൻ ഫയലിൻ്റെ സ്ഥാനം വ്യക്തമാക്കുന്നു. Git ട്രാക്ക് ചെയ്യുന്നത് തടയാൻ ഈ ഫയൽ നിങ്ങളുടെ .gitignore-ൽ ഉൾപ്പെടുത്തുന്നത് നല്ലതാണ്.

ഉദാഹരണം: നൂറുകണക്കിന് ടൈപ്പ്സ്ക്രിപ്റ്റ് ഫയലുകളുള്ള ഒരു വലിയ ഇ-കൊമേഴ്‌സ് ആപ്ലിക്കേഷൻ സങ്കൽപ്പിക്കുക. ഇൻക്രിമെൻ്റൽ കംപൈലേഷൻ ഇല്ലാതെ, ഒരു മുഴുവൻ ബിൽഡിന് നിരവധി മിനിറ്റുകൾ എടുത്തേക്കാം. ഇൻക്രിമെൻ്റൽ കംപൈലേഷൻ പ്രവർത്തനക്ഷമമാക്കിയാൽ, ചെറിയ കോഡ് മാറ്റങ്ങൾക്ക് ശേഷമുള്ള ബിൽഡുകൾക്ക് കുറച്ച് സെക്കൻഡുകൾ മാത്രമേ എടുക്കൂ.

2. പ്രോജക്റ്റ് റെഫറൻസുകൾ

വലിയ പ്രോജക്റ്റുകൾക്കായി, അവയെ ചെറിയ, കൈകാര്യം ചെയ്യാൻ എളുപ്പമുള്ള മൊഡ്യൂളുകളോ ലൈബ്രറികളോ ആയി വിഭജിക്കുന്നത് പരിഗണിക്കുക. ടൈപ്പ്സ്ക്രിപ്റ്റിൻ്റെ പ്രോജക്റ്റ് റെഫറൻസസ് ഫീച്ചർ നിങ്ങളുടെ കോഡ്ബേസ് പരസ്പരം ബന്ധിപ്പിച്ചിട്ടുള്ള പ്രോജക്റ്റുകളുടെ ഒരു കൂട്ടമായി ക്രമീകരിക്കാൻ അനുവദിക്കുന്നു. ഇത് കംപൈലറിനെ പ്രോജക്റ്റുകൾ സമാന്തരമായും ഇൻക്രിമെൻ്റലായും നിർമ്മിക്കാൻ സഹായിക്കുന്നു, ഇത് ബിൽഡ് സമയം കൂടുതൽ കുറയ്ക്കുന്നു.

പ്രോജക്റ്റ് റെഫറൻസുകൾ ഉപയോഗിക്കുന്നതിന്, ഓരോ സബ് പ്രോജക്റ്റിനും ഒരു tsconfig.json ഫയൽ ഉണ്ടാക്കുക. പ്രധാന പ്രോജക്റ്റിൻ്റെ tsconfig.json-ൽ, സബ് പ്രോജക്റ്റ് tsconfig.json ഫയലുകളിലേക്കുള്ള പാതകൾ ലിസ്റ്റ് ചെയ്യുന്ന ഒരു references അറേ ചേർക്കുക:

            {
  "compilerOptions": {
    "composite": true, // Required for project references
    "declaration": true, // Required for project references
    "declarationMap": true,
    "incremental": true,
    "tsBuildInfoFile": ".tsbuildinfo"
  },
  "files": [], // Explicitly exclude files; include using `references`
  "references": [
    { "path": "./core" },
    { "path": "./ui" },
    { "path": "./api" }
  ]
}
            

              
                Copy
              
            
          

റഫറൻസ് ചെയ്യപ്പെട്ട ഓരോ പ്രോജക്റ്റിൻ്റെയും tsconfig.json-ൽ composite: true, declaration: true എന്നിവ ഉണ്ടായിരിക്കണം. ഇത് ടൈപ്പ്സ്ക്രിപ്റ്റിനെ ഓരോ സബ് പ്രോജക്റ്റിനും ഡിക്ലറേഷൻ ഫയലുകൾ (.d.ts) ജനറേറ്റ് ചെയ്യാൻ സഹായിക്കുന്നു, അവയെ ആശ്രയിക്കുന്ന മറ്റ് പ്രോജക്റ്റുകൾ ഇത് ഉപയോഗിക്കുന്നു.

ഉദാഹരണം: ഒരു കോർ ലൈബ്രറി, ഒരു യുഐ ലൈബ്രറി, ഒരു എപിഐ ക്ലയിൻ്റ് ലൈബ്രറി എന്നിവയുള്ള ഒരു വെബ് ആപ്ലിക്കേഷൻ പരിഗണിക്കുക. ഓരോ ലൈബ്രറിയും അതിൻ്റേതായ tsconfig.json ഉള്ള ഒരു പ്രത്യേക പ്രോജക്റ്റ് ആകാം. പ്രധാന ആപ്ലിക്കേഷൻ പ്രോജക്റ്റിന് ഈ ലൈബ്രറികളെ റഫറൻസ് ചെയ്യാൻ കഴിയും, ഇത് ടൈപ്പ്സ്ക്രിപ്റ്റിനെ അവയെ സ്വതന്ത്രമായും സമാന്തരമായും നിർമ്മിക്കാൻ അനുവദിക്കുന്നു.

3. മൊഡ്യൂൾ റെസൊല്യൂഷൻ സ്ട്രാറ്റജികൾ

കംപൈലർ എങ്ങനെ മൊഡ്യൂൾ ഡിപൻഡൻസികൾ കണ്ടെത്തുകയും പരിഹരിക്കുകയും ചെയ്യുന്നു എന്ന് ടൈപ്പ്സ്ക്രിപ്റ്റിൻ്റെ മൊഡ്യൂൾ റെസൊല്യൂഷൻ സ്ട്രാറ്റജി നിർണ്ണയിക്കുന്നു. ഡിഫോൾട്ട് സ്ട്രാറ്റജിയായ classic, കാര്യക്ഷമമല്ലാത്തതാവാം, പ്രത്യേകിച്ചും വലിയ പ്രോജക്റ്റുകളിൽ. node മൊഡ്യൂൾ റെസൊല്യൂഷൻ സ്ട്രാറ്റജിയിലേക്ക് മാറുന്നത് കംപൈലേഷൻ വേഗത ഗണ്യമായി മെച്ചപ്പെടുത്തും.

node മൊഡ്യൂൾ റെസൊല്യൂഷൻ സ്ട്രാറ്റജി ഉപയോഗിക്കാൻ, നിങ്ങളുടെ tsconfig.json ഫയലിൽ moduleResolution ഓപ്ഷൻ node ആയി സജ്ജമാക്കുക:

            {
  "compilerOptions": {
    "moduleResolution": "node"
  }
}
            

              
                Copy
              
            
          

node മൊഡ്യൂൾ റെസൊല്യൂഷൻ സ്ട്രാറ്റജി Node.js-ൻ്റെ മൊഡ്യൂൾ റെസൊല്യൂഷൻ അൽഗോരിതം അനുകരിക്കുന്നു, ഇത് സാധാരണയായി കൂടുതൽ കാര്യക്ഷമവും പ്രവചിക്കാവുന്നതുമാണ്.

കൂടാതെ, നിങ്ങൾ `baseUrl`, `paths` എന്നീ കംപൈലർ ഓപ്ഷനുകൾ ശരിയായി ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്നത് മൊഡ്യൂൾ റെസൊല്യൂഷൻ്റെ വേഗത ഗണ്യമായി വർദ്ധിപ്പിക്കും. `baseUrl` നോൺ-അബ്സൊല്യൂട്ട് മൊഡ്യൂൾ പേരുകൾ പരിഹരിക്കുന്നതിനുള്ള ബേസ് ഡയറക്ടറി വ്യക്തമാക്കുന്നു. `paths` മൊഡ്യൂൾ പാതകൾക്കായി അപരനാമങ്ങൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

            {
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@core/*": ["src/core/*"],
      "@ui/*": ["src/ui/*"]
    }
  }
}
            

              
                Copy
              
            
          

ഉദാഹരണം: ഒരു പ്രോജക്റ്റിന് ആഴത്തിൽ നെസ്റ്റ് ചെയ്ത മൊഡ്യൂൾ ഡയറക്ടറികൾ ഉണ്ടാകാം. `baseUrl`, `paths` എന്നിവ ഉപയോഗിക്കുന്നത് ദൈർഘ്യമേറിയ റിലേറ്റീവ് പാതകൾ (ഉദാഹരണത്തിന്, ../../../../utils/helpers) ഒഴിവാക്കാനും മൊഡ്യൂൾ റെസൊല്യൂഷൻ വേഗത്തിലാക്കാനും സഹായിക്കും.

4. ടാർഗെറ്റഡ് കംപൈലേഷൻ

ഓരോ തവണയും മുഴുവൻ പ്രോജക്റ്റും കംപൈൽ ചെയ്യുന്നതിനുപകരം, നിങ്ങൾക്ക് നിർദ്ദിഷ്ട ഫയലുകളെയോ ഡയറക്ടറികളെയോ ടാർഗെറ്റുചെയ്യാനാകും. നിങ്ങൾ കോഡ്ബേസിൻ്റെ ഒരു ചെറിയ ഭാഗത്ത് മാത്രം പ്രവർത്തിക്കുമ്പോൾ ഡെവലപ്മെൻ്റ് സമയത്ത് ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. നിർദ്ദിഷ്ട ഫയലുകളെ ടാർഗെറ്റുചെയ്യാൻ `tsc` കമാൻഡ് ലൈൻ ഉപയോഗിക്കുക.

            
tsc src/components/MyComponent.ts

            

              
                Copy
              
            
          

ഇത് `MyComponent.ts`-നെയും അതിൻ്റെ ഡിപൻഡൻസികളെയും മാത്രം കംപൈൽ ചെയ്യും.

പ്രോജക്റ്റ് റെഫറൻസുകൾ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് വ്യക്തിഗത സബ്-പ്രോജക്റ്റുകൾ കംപൈൽ ചെയ്യാൻ കഴിയും:

            
tsc -b core

            

              
                Copy
              
            
          

ഈ കമാൻഡ് നിങ്ങളുടെ references അറേയിൽ നിർവചിച്ചിട്ടുള്ള `core` പ്രോജക്റ്റിനെ കംപൈൽ ചെയ്യുന്നു.

5. ടൈപ്പ് ചെക്കിംഗ് ഓവർഹെഡ് കുറയ്ക്കുക

ടൈപ്പ്സ്ക്രിപ്റ്റിൻ്റെ സ്റ്റാറ്റിക് ടൈപ്പിംഗ് ഒരു വലിയ നേട്ടമാണെങ്കിലും, അത് കംപൈലേഷൻ ഓവർഹെഡിനും കാരണമാകും. സങ്കീർണ്ണമായ ജെനറിക്കുകൾ, യൂണിയൻ ടൈപ്പുകൾ തുടങ്ങിയ ചില ഫീച്ചറുകൾ ടൈപ്പ്-ചെക്ക് ചെയ്യാൻ ചെലവേറിയതാണ്. ഇനിപ്പറയുന്ന സ്ട്രാറ്റജികൾ പരിഗണിക്കുക:

• എക്സ്പ്ലിസിറ്റ് ടൈപ്പുകൾ ഉപയോഗിക്കുക: ടൈപ്പുകൾ വ്യക്തമായി നിർവചിക്കുന്നത് ചിലപ്പോൾ കംപൈലറിന് ടൈപ്പുകൾ കൂടുതൽ കാര്യക്ഷമമായി ഇൻഫർ ചെയ്യാൻ സഹായിക്കും.
• അമിതമായ ജെനറിക്കുകൾ ഒഴിവാക്കുക: ജെനറിക്കുകളുടെ അമിതമായ ഉപയോഗം സങ്കീർണ്ണമായ ടൈപ്പ് ഇൻഫറൻസുകളിലേക്ക് നയിച്ചേക്കാം. സാധ്യമാകുമ്പോൾ കൂടുതൽ നിർദ്ദിഷ്ട ടൈപ്പുകൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.
• യൂണിയൻ ടൈപ്പുകൾ ലളിതമാക്കുക: വലിയ യൂണിയൻ ടൈപ്പുകൾ പരിശോധിക്കാൻ ചെലവേറിയതാണ്. ടൈപ്പ് ഡെഫനിഷനുകൾ ലളിതമാക്കാൻ ഡിസ്ക്രിമിനേറ്റഡ് യൂണിയനുകളോ മറ്റ് ടെക്നിക്കുകളോ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.
• `any` ഉപയോഗിക്കുക (ജാഗ്രതയോടെ): പൊതുവെ നിരുത്സാഹപ്പെടുത്തുന്നുണ്ടെങ്കിലും, പെർഫോമൻസ് നിർണായകവും ടൈപ്പ് സുരക്ഷ അത്ര പ്രധാനമല്ലാത്തതുമായ പ്രത്യേക സാഹചര്യങ്ങളിൽ ടൈപ്പ് ചെക്കിംഗ് ഒഴിവാക്കാൻ `any` ഉപയോഗിക്കാം. എന്നിരുന്നാലും, ഇത് വളരെ കുറച്ച് മാത്രം ഉപയോഗിക്കുക, കാരണം ഇത് ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നതിൻ്റെ ഉദ്ദേശ്യത്തെ തന്നെ പരാജയപ്പെടുത്തുന്നു.
• `--noImplicitAny`: `tsconfig.json`-ൽ ഈ ഫ്ലാഗ് `true` ആയി സജ്ജീകരിക്കുന്നത് ടൈപ്പുകൾ വ്യക്തമായി രേഖപ്പെടുത്താൻ നിങ്ങളെ നിർബന്ധിക്കുന്നു, ഇത് ടൈപ്പ് ഇൻഫറൻസിൽ കംപൈലറിനെ സഹായിക്കും.

ഉദാഹരണം: T എന്തും ആകാവുന്ന Array<T> പോലുള്ള ഒരു ജെനറിക് ടൈപ്പ് ഉപയോഗിക്കുന്നതിനുപകരം, അറേയിൽ സ്ട്രിംഗുകളോ നമ്പറുകളോ മാത്രമേ ഉള്ളൂവെന്ന് അറിയാമെങ്കിൽ Array<string> അല്ലെങ്കിൽ Array<number> പോലുള്ള കൂടുതൽ നിർദ്ദിഷ്ട ടൈപ്പ് ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.

6. കംപൈലർ ഓപ്ഷൻസ് ഒപ്റ്റിമൈസേഷൻ

tsconfig.json-ലെ നിരവധി കംപൈലർ ഓപ്ഷനുകൾ കംപൈലേഷൻ വേഗതയെ ബാധിക്കും. പെർഫോമൻസ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിന് ഈ ഓപ്ഷനുകൾ ക്രമീകരിക്കുന്നത് പരിഗണിക്കുക:

• `target`: നിങ്ങളുടെ റൺടൈം എൻവയോൺമെൻ്റുമായി പൊരുത്തപ്പെടുന്ന ഒരു ടാർഗെറ്റ് ജാവാസ്ക്രിപ്റ്റ് പതിപ്പ് തിരഞ്ഞെടുക്കുക. പഴയ പതിപ്പുകൾ (ഉദാഹരണത്തിന്, ES5) ടാർഗെറ്റുചെയ്യുന്നതിന് കൂടുതൽ കോഡ് ട്രാൻസ്ഫോർമേഷനുകൾ ആവശ്യമായി വന്നേക്കാം, ഇത് കംപൈലേഷൻ സമയം വർദ്ധിപ്പിക്കുന്നു. പുതിയ പതിപ്പുകൾ (ഉദാഹരണത്തിന്, `ES2020`, `ESNext`) ടാർഗെറ്റുചെയ്യുന്നത് വേഗതയേറിയ കംപൈലേഷന് കാരണമാകും.
• `module`: മൊഡ്യൂൾ കോഡ് ജനറേഷൻ ശൈലി വ്യക്തമാക്കുന്നു (ഉദാഹരണത്തിന്, commonjs, esnext, amd). ആധുനിക ബണ്ട്ലറുകൾക്ക് `esnext` പലപ്പോഴും വേഗതയേറിയതാണ്.
• `sourceMap`: കംപൈലേഷൻ സമയവും ഔട്ട്പുട്ട് വലുപ്പവും കുറയ്ക്കുന്നതിന് പ്രൊഡക്ഷൻ ബിൽഡുകളിൽ സോഴ്സ് മാപ്പ് ജനറേഷൻ പ്രവർത്തനരഹിതമാക്കുക. നിങ്ങളുടെ പ്രൊഡക്ഷൻ tsconfig.json-ൽ sourceMap false ആയി സജ്ജമാക്കുക.
• `declaration`: ആവശ്യമുള്ളപ്പോൾ മാത്രം ഡിക്ലറേഷൻ ഫയൽ ജനറേഷൻ (.d.ts) പ്രവർത്തനക്ഷമമാക്കുക. ഡിക്ലറേഷൻ ഫയലുകൾ ജനറേറ്റ് ചെയ്യേണ്ടതില്ലെങ്കിൽ ഡെവലപ്മെൻ്റ് ബിൽഡുകൾക്കായി ഇത് പ്രവർത്തനരഹിതമാക്കുക.
• `removeComments`: കംപൈലേഷൻ സമയത്ത് കമൻ്റുകൾ നീക്കംചെയ്യുന്നത് ബിൽഡ് സമയം അല്പം മെച്ചപ്പെടുത്താനും ഔട്ട്പുട്ട് വലുപ്പം കുറയ്ക്കാനും സഹായിക്കും. removeComments true ആയി സജ്ജമാക്കുക.
• `importHelpers`: ഒരു ഹെൽപ്പർ ലൈബ്രറി (tslib പോലുള്ളവ) ഉപയോഗിക്കുന്നത് ഓരോ മൊഡ്യൂളിലും ഹെൽപ്പർ ഫംഗ്ഷനുകൾ ഇൻജെക്റ്റ് ചെയ്യുന്നത് ഒഴിവാക്കുന്നു, ഇത് കോഡിൻ്റെ വലുപ്പവും കംപൈലേഷൻ സമയവും കുറയ്ക്കും. `importHelpers` true ആയി സജ്ജമാക്കി `tslib` ഇൻസ്റ്റാൾ ചെയ്യുക.
• `isolatedModules`: ടൈപ്പ്സ്ക്രിപ്റ്റിന് *മുമ്പ്* ട്രാൻസ്പൈലേഷനായി നിങ്ങൾ Babel പോലുള്ള ഒരു ടൂൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, ഈ ഫ്ലാഗ് true ആയി സജ്ജീകരിക്കുന്നത് ഓരോ ഫയലും ഒരു പ്രത്യേക മൊഡ്യൂളായി കംപൈൽ ചെയ്യാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു. ഇത് ചില സാഹചര്യങ്ങളിൽ വേഗതയേറിയ ബിൽഡുകൾക്ക് സഹായിക്കും.

ഉദാഹരണം: ഏറ്റവും പുതിയ ബ്രൗസറുകളെ ടാർഗെറ്റുചെയ്യുന്ന ഒരു ആധുനിക വെബ് ആപ്ലിക്കേഷനായി, നിങ്ങൾ "target": "ESNext", "module": "esnext" എന്നിവ ഉപയോഗിച്ചേക്കാം.

7. ബിൽഡ് ടൂളുകളും ബണ്ട്ലറുകളും പ്രയോജനപ്പെടുത്തുക

വെബ്പാക്ക്, റോൾഅപ്പ്, പാർസൽ പോലുള്ള ടൂളുകൾക്ക് ടൈപ്പ്സ്ക്രിപ്റ്റ് ബിൽഡ് പെർഫോമൻസ് ഗണ്യമായി മെച്ചപ്പെടുത്താൻ കഴിയും. ഈ ടൂളുകൾ വിവിധ ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകൾ ഉപയോഗിക്കുന്നു, അവയിൽ ചിലത്:

• ട്രീ ഷേക്കിംഗ്: ഔട്ട്പുട്ട് വലുപ്പം കുറയ്ക്കുന്നതിന് ഉപയോഗിക്കാത്ത കോഡ് ഒഴിവാക്കുന്നു.
• കോഡ് സ്പ്ലിറ്റിംഗ്: ആപ്ലിക്കേഷനെ ആവശ്യാനുസരണം ലോഡ് ചെയ്യാൻ കഴിയുന്ന ചെറിയ ഭാഗങ്ങളായി വിഭജിക്കുന്നു.
• കാഷിംഗ്: അനാവശ്യ കംപൈലേഷൻ ഒഴിവാക്കാൻ ബിൽഡ് ഫലങ്ങൾ കാഷെ ചെയ്യുന്നു.
• സമാന്തരവൽക്കരണം: ഒന്നിലധികം സിപിയു കോറുകൾ ഉപയോഗിക്കുന്നതിന് ബിൽഡ് ടാസ്കുകൾ സമാന്തരമായി പ്രവർത്തിപ്പിക്കുന്നു.

ബിൽഡ് ടൂളുകളുമായി ടൈപ്പ്സ്ക്രിപ്റ്റ് സംയോജിപ്പിക്കുമ്പോൾ, ടൈപ്പ്സ്ക്രിപ്റ്റിനായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്ത പ്ലഗിനുകളും ലോഡറുകളും ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക, ഉദാഹരണത്തിന് വെബ്പാക്കിനായി ts-loader അല്ലെങ്കിൽ esbuild-loader, അല്ലെങ്കിൽ പാർസലിലെ ബിൽറ്റ്-ഇൻ ടൈപ്പ്സ്ക്രിപ്റ്റ് സപ്പോർട്ട്. ഈ ടൂളുകൾ പലപ്പോഴും അധിക ഒപ്റ്റിമൈസേഷൻ ഓപ്ഷനുകളും മറ്റ് ബിൽഡ് ടൂളുകളുമായുള്ള സംയോജനവും വാഗ്ദാനം ചെയ്യുന്നു.

ഉദാഹരണം: വെബ്പാക്ക് ts-loader ഉപയോഗിച്ച് കാഷിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നത് വലിയ വെബ് ആപ്ലിക്കേഷനുകളുടെ ബിൽഡ് സമയം ഗണ്യമായി കുറയ്ക്കും. പ്രാരംഭ ബിൽഡിന് കൂടുതൽ സമയമെടുത്തേക്കാം, എന്നാൽ കാഷിംഗ് കാരണം തുടർന്നുള്ള ബിൽഡുകൾ വളരെ വേഗത്തിലായിരിക്കും.

8. വേഗതയേറിയ ട്രാൻസ്പൈലറുകൾ/ചെക്കറുകൾ ഉപയോഗിക്കുക

ഔദ്യോഗിക `tsc` എല്ലായ്പ്പോഴും ഏറ്റവും വേഗതയേറിയ ഓപ്ഷനല്ല. ഇനിപ്പറയുന്ന ബദലുകൾ പരിഗണിക്കുക:

• esbuild: Go-യിൽ എഴുതിയ വളരെ വേഗതയേറിയ ഒരു ജാവാസ്ക്രിപ്റ്റ്, ടൈപ്പ്സ്ക്രിപ്റ്റ് ബണ്ട്ലറും ട്രാൻസ്പൈലറുമാണ് ഇത്. ട്രാൻസ്പൈലേഷനായി `tsc`-യെക്കാൾ വളരെ വേഗതയുള്ളതാകാം, പക്ഷേ അതേ നിലവാരത്തിലുള്ള ടൈപ്പ് ചെക്കിംഗ് കാഠിന്യം നൽകണമെന്നില്ല.
• swc: Rust അടിസ്ഥാനമാക്കിയുള്ള മറ്റൊരു ടൂൾ, ട്രാൻസ്പൈലേഷനും ബണ്ട്ലിംഗിനും അവിശ്വസനീയമാംവിധം വേഗതയുള്ളതാണ്.
• ts-patch + @typescript-eslint/typescript-estree: നിങ്ങളുടെ പ്രോജക്റ്റ് ESLint, `@typescript-eslint` എന്നിവയെ വളരെയധികം ആശ്രയിക്കുന്നുവെങ്കിൽ, ഈ കോമ്പിനേഷൻ കൂടുതൽ മികച്ച പ്രകടനം കാഴ്ചവയ്ക്കുന്ന AST ഉപയോഗിക്കുന്നതിന് ടൈപ്പ്സ്ക്രിപ്റ്റിനെ പാച്ച് ചെയ്തുകൊണ്ട് നിങ്ങളുടെ ലിൻ്റിംഗ് പ്രക്രിയ വേഗത്തിലാക്കാൻ സഹായിക്കും.

പലപ്പോഴും, ഏറ്റവും മികച്ച സമീപനം ഇവയുടെ ഒരു സംയോജനമാണ്: ടൈപ്പ് ചെക്കിംഗിനായി `tsc` ഒരു പ്രത്യേക പ്രോസസ്സിലോ (അല്ലെങ്കിൽ നിങ്ങളുടെ IDE-യിലോ) ഉപയോഗിക്കുക, തുടർന്ന് യഥാർത്ഥ ട്രാൻസ്പൈലേഷനും ബണ്ട്ലിംഗിനും `esbuild` അല്ലെങ്കിൽ `swc` ഉപയോഗിക്കുക.

9. കംപൈലേഷൻ വേഗത നിരീക്ഷിക്കുകയും പ്രൊഫൈൽ ചെയ്യുകയും ചെയ്യുക

തടസ്സങ്ങൾ തിരിച്ചറിയുന്നതിനും നിങ്ങളുടെ ഒപ്റ്റിമൈസേഷൻ ശ്രമങ്ങളുടെ ഫലപ്രാപ്തി ട്രാക്ക് ചെയ്യുന്നതിനും നിങ്ങളുടെ ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലേഷൻ വേഗത പതിവായി നിരീക്ഷിക്കുകയും പ്രൊഫൈൽ ചെയ്യുകയും ചെയ്യുക. കംപൈലേഷൻ സമയത്തെക്കുറിച്ചുള്ള വിശദമായ വിവരങ്ങൾ ലഭിക്കുന്നതിന് `tsc`-യിലെ --diagnostics ഫ്ലാഗ് പോലുള്ള ടൂളുകൾ ഉപയോഗിക്കുക.

            
tsc --diagnostics

            

              
                Copy
              
            
          

ഇത് പാഴ്സിംഗ്, ടൈപ്പ് ചെക്കിംഗ്, കോഡ് ജനറേഷൻ തുടങ്ങിയ കംപൈലേഷൻ പ്രക്രിയയുടെ വിവിധ ഘട്ടങ്ങളിൽ ചെലവഴിച്ച സമയത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ നൽകും. ഒപ്റ്റിമൈസേഷൻ ശ്രമങ്ങൾ ഏറ്റവും കൂടുതൽ സ്വാധീനം ചെലുത്താൻ സാധ്യതയുള്ള മേഖലകൾ തിരിച്ചറിയാൻ നിങ്ങൾക്ക് ഈ വിവരങ്ങൾ ഉപയോഗിക്കാം.

ഉദാഹരണം: ടൈപ്പ് ചെക്കിംഗിന് ഗണ്യമായ സമയം എടുക്കുന്നുവെന്ന് ഡയഗ്നോസ്റ്റിക്സ് റിപ്പോർട്ട് കാണിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ ടൈപ്പ് ഡെഫനിഷനുകൾ ലളിതമാക്കുന്നതിലോ സങ്കീർണ്ണമായ ജെനറിക്കുകളുടെ ഉപയോഗം കുറയ്ക്കുന്നതിലോ ശ്രദ്ധ കേന്ദ്രീകരിക്കാം.

10. നിങ്ങളുടെ IDE-യും എഡിറ്ററും ഒപ്റ്റിമൈസ് ചെയ്യുക

നിങ്ങളുടെ IDE അല്ലെങ്കിൽ എഡിറ്ററും പ്രകടമായ പ്രകടനത്തെ സ്വാധീനിക്കും. നിങ്ങളുടെ IDE-യുടെയും ടൈപ്പ്സ്ക്രിപ്റ്റ് പ്ലഗിന്നുകളുടെയും ഏറ്റവും പുതിയ പതിപ്പുകളാണ് നിങ്ങൾ ഉപയോഗിക്കുന്നതെന്ന് ഉറപ്പാക്കുക. ഒരു ഗ്ലോബൽ പതിപ്പിനുപകരം പ്രോജക്റ്റിൻ്റെ ടൈപ്പ്സ്ക്രിപ്റ്റ് പതിപ്പ് ഉപയോഗിക്കാൻ നിങ്ങളുടെ IDE കോൺഫിഗർ ചെയ്യുക. ഓട്ടോമാറ്റിക് ടൈപ്പ് ചെക്കിംഗ് അല്ലെങ്കിൽ കോഡ് കംപ്ലീഷൻ പോലുള്ള ഫീച്ചറുകൾ നിങ്ങളുടെ വർക്ക്ഫ്ലോയെ മന്ദഗതിയിലാക്കുന്നുവെങ്കിൽ അവ പ്രവർത്തനരഹിതമാക്കുന്നത് പരിഗണിക്കുക.

ഉപസംഹാരം

ഉത്പാദനക്ഷമവും കാര്യക്ഷമവുമായ ഒരു ഡെവലപ്മെൻ്റ് വർക്ക്ഫ്ലോ നിലനിർത്തുന്നതിന് ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലേഷൻ വേഗത ഒപ്റ്റിമൈസ് ചെയ്യേണ്ടത് അത്യാവശ്യമാണ്. ഈ ലേഖനത്തിൽ വിവരിച്ചിരിക്കുന്ന ടെക്നിക്കുകൾ നടപ്പിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് ബിൽഡ് സമയം ഗണ്യമായി കുറയ്ക്കാനും, ഡെവലപ്പർ സംതൃപ്തി മെച്ചപ്പെടുത്താനും, ഉയർന്ന നിലവാരമുള്ള സോഫ്റ്റ്‌വെയറിൻ്റെ ഡെലിവറി ത്വരിതപ്പെടുത്താനും കഴിയും. കൂടുതൽ ഒപ്റ്റിമൈസേഷനുള്ള മേഖലകൾ തിരിച്ചറിയുന്നതിനും നിങ്ങളുടെ ശ്രമങ്ങൾക്ക് ആഗ്രഹിച്ച ഫലം ലഭിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്നതിനും നിങ്ങളുടെ കംപൈലേഷൻ വേഗത തുടർച്ചയായി നിരീക്ഷിക്കുകയും പ്രൊഫൈൽ ചെയ്യുകയും ചെയ്യുക. നിങ്ങളുടെ നിർദ്ദിഷ്ട പ്രോജക്റ്റിനും ഡെവലപ്മെൻ്റ് എൻവയോൺമെൻ്റിനും അനുയോജ്യമായ നിരവധി ടെക്നിക്കുകളുടെ സംയോജനമാണ് പലപ്പോഴും ഏറ്റവും മികച്ച ഒപ്റ്റിമൈസേഷൻ സ്ട്രാറ്റജി.