ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂൾ സ്റ്റാൻഡേർഡുകൾ: എക്മാസ്ക്രിപ്റ്റ് അനുയോജ്യതയുടെയും പരിണാമത്തിൻ്റെയും ഒരു ആഴത്തിലുള്ള വിശകലനം

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

ഈ സമഗ്രമായ ഗൈഡ് ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂൾ സ്റ്റാൻഡേർഡുകളുടെ സമ്പൂർണ്ണ ചരിത്രത്തിലൂടെയും നിലവിലെ അവസ്ഥയിലൂടെയും നിങ്ങളെ കൊണ്ടുപോകും. ആശയക്കുഴപ്പങ്ങൾ നിയന്ത്രിക്കാൻ ശ്രമിച്ച ആദ്യകാല പാറ്റേണുകൾ, ഒരു സെർവർ-സൈഡ് വിപ്ലവത്തിന് ശക്തി പകർന്ന കമ്മ്യൂണിറ്റി-ഡ്രൈിവൺ സ്റ്റാൻഡേർഡുകൾ, ഒടുവിൽ ഇന്ന് ഈ ആവാസവ്യവസ്ഥയെ ഒന്നിപ്പിക്കുന്ന ഔദ്യോഗിക എക്മാസ്ക്രിപ്റ്റ് മൊഡ്യൂൾസ് (ESM) സ്റ്റാൻഡേർഡ് എന്നിവയെക്കുറിച്ച് നമ്മൾ പര്യവേക്ഷണം ചെയ്യും. നിങ്ങൾ import, export എന്നിവയെക്കുറിച്ച് പഠിക്കുന്ന ഒരു ജൂനിയർ ഡെവലപ്പറോ അല്ലെങ്കിൽ ഹൈബ്രിഡ് കോഡ്‌ബേസുകളുടെ സങ്കീർണ്ണതകൾ കൈകാര്യം ചെയ്യുന്ന ഒരു പരിചയസമ്പന്നനായ ആർക്കിടെക്റ്റോ ആകട്ടെ, ഈ ലേഖനം ജാവാസ്ക്രിപ്റ്റിന്റെ ഏറ്റവും നിർണായകമായ സവിശേഷതകളിലൊന്നിനെക്കുറിച്ച് വ്യക്തതയും ആഴത്തിലുള്ള ഉൾക്കാഴ്ചയും നൽകും.

മൊഡ്യൂളിന് മുമ്പുള്ള കാലഘട്ടം: ഗ്ലോബൽ സ്കോപ്പിൻ്റെ അനിയന്ത്രിതമായ ലോകം

ഔദ്യോഗികമായ മൊഡ്യൂൾ സിസ്റ്റങ്ങൾ നിലവിൽ വരുന്നതിന് മുമ്പ്, ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്‌മെൻ്റ് വളരെ അപകടകരമായ ഒന്നായിരുന്നു. സാധാരണയായി ഒന്നിലധികം <script> ടാഗുകൾ വഴി ഒരു വെബ് പേജിൽ കോഡ് ഉൾപ്പെടുത്തുകയായിരുന്നു പതിവ്. ഈ ലളിതമായ സമീപനത്തിന് വലിയതും അപകടകരവുമായ ഒരു പാർശ്വഫലമുണ്ടായിരുന്നു: ഗ്ലോബൽ സ്കോപ്പ് പൊല്യൂഷൻ.

ഒരു സ്ക്രിപ്റ്റ് ഫയലിൻ്റെ ഏറ്റവും മുകളിൽ ഡിക്ലയർ ചെയ്യുന്ന ഓരോ വേരിയബിളും, ഫംഗ്ഷനും, അല്ലെങ്കിൽ ഒബ്ജക്റ്റും ഗ്ലോബൽ ഒബ്ജക്റ്റിലേക്ക് (ബ്രൗസറുകളിൽ window) ചേർക്കപ്പെട്ടു. ഇത് ദുർബലമായ ഒരു സാഹചര്യം സൃഷ്ടിച്ചു, അവിടെ:

• പേരുകളിലെ വൈരുദ്ധ്യം: രണ്ട് വ്യത്യസ്ത സ്ക്രിപ്റ്റുകൾ ഒരേ വേരിയബിൾ നാമം അബദ്ധത്തിൽ ഉപയോഗിക്കുകയും, ഒന്ന് മറ്റൊന്നിനെ തിരുത്തിയെഴുതുകയും ചെയ്യാം. ഇത്തരം പ്രശ്നങ്ങൾ ഡീബഗ്ഗ് ചെയ്യുന്നത് പലപ്പോഴും ഒരു പേടിസ്വപ്നമായിരുന്നു.
• പരോക്ഷമായ ആശ്രിതത്വം: <script> ടാഗുകളുടെ ക്രമം നിർണായകമായിരുന്നു. മറ്റൊരു സ്ക്രിപ്റ്റിലെ ഒരു വേരിയബിളിനെ ആശ്രയിക്കുന്ന ഒരു സ്ക്രിപ്റ്റ്, അതിൻ്റെ ഡിപൻഡൻസിക്ക് ശേഷം ലോഡ് ചെയ്യണമായിരുന്നു. ഈ മാനുവൽ ഓർഡറിംഗ് ദുർബലവും പരിപാലിക്കാൻ ബുദ്ധിമുട്ടുള്ളതുമായിരുന്നു.
• എൻക്യാപ്‌സുലേഷൻ്റെ അഭാവം: പ്രൈവറ്റ് വേരിയബിളുകളോ ഫംഗ്ഷനുകളോ സൃഷ്ടിക്കാൻ ഒരു മാർഗവുമില്ലായിരുന്നു. എല്ലാം പുറത്തുനിന്നും ലഭ്യമായിരുന്നു, ഇത് കരുത്തുറ്റതും സുരക്ഷിതവുമായ കമ്പോണൻ്റുകൾ നിർമ്മിക്കുന്നത് ബുദ്ധിമുട്ടാക്കി.

IIFE പാറ്റേൺ: ഒരു പ്രതീക്ഷയുടെ കിരണം

ഈ പ്രശ്‌നങ്ങളെ നേരിടാൻ, സമർത്ഥരായ ഡെവലപ്പർമാർ മൊഡ്യൂളാരിറ്റി അനുകരിക്കാൻ ചില പാറ്റേണുകൾ ആവിഷ്കരിച്ചു. ഇതിൽ ഏറ്റവും പ്രമുഖമായത് ഇമ്മീഡിയറ്റ്‌ലി ഇൻവോക്ക്ഡ് ഫംഗ്ഷൻ എക്സ്പ്രഷൻ (IIFE) ആയിരുന്നു. ഒരു IIFE എന്നത് നിർവചിക്കുകയും ഉടനടി എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷനാണ്.

ഇതിനൊരു ക്ലാസിക് ഉദാഹരണം ഇതാ:

            (function() {
  // All the code inside this function is in a private scope.
  var privateVariable = 'I am safe here';

  function privateFunction() {
    console.log('This function cannot be called from outside.');
  }

  // We can choose what to expose to the global scope.
  window.myModule = {
    publicMethod: function() {
      console.log('Hello from the public method!');
      privateFunction();
    }
  };
})();

// Usage:
myModule.publicMethod(); // Works
console.log(typeof privateVariable); // undefined
privateFunction(); // Throws an error
            

              
                Copy
              
            
          

IIFE പാറ്റേൺ ഒരു നിർണായക സവിശേഷത നൽകി: സ്കോപ്പ് എൻക്യാപ്‌സുലേഷൻ. കോഡ് ഒരു ഫംഗ്ഷനിൽ പൊതിയുന്നതിലൂടെ, അത് ഒരു പ്രൈവറ്റ് സ്കോപ്പ് സൃഷ്ടിക്കുകയും വേരിയബിളുകൾ ഗ്ലോബൽ നെയിംസ്പേസിലേക്ക് ചോരുന്നത് തടയുകയും ചെയ്തു. ഡെവലപ്പർമാർക്ക് അവർ പുറത്തുവിടാൻ ആഗ്രഹിക്കുന്ന ഭാഗങ്ങൾ (അവരുടെ പബ്ലിക് API) ഗ്ലോബൽ window ഒബ്ജക്റ്റിലേക്ക് വ്യക്തമായി ചേർക്കാൻ കഴിഞ്ഞു. ഇതൊരു വലിയ മെച്ചപ്പെടുത്തലായിരുന്നെങ്കിലും, ഡിപൻഡൻസി മാനേജ്‌മെൻ്റുള്ള ഒരു യഥാർത്ഥ മൊഡ്യൂൾ സിസ്റ്റം എന്നതിലുപരി, ഇത് ഒരു മാനുവൽ രീതി മാത്രമായിരുന്നു.

കമ്മ്യൂണിറ്റി സ്റ്റാൻഡേർഡുകളുടെ ഉദയം: കോമൺജെഎസ് (CJS)

ജാവാസ്ക്രിപ്റ്റിൻ്റെ ഉപയോഗം ബ്രൗസറിനപ്പുറത്തേക്ക് വ്യാപിച്ചതോടെ, പ്രത്യേകിച്ച് 2009-ൽ നോഡ്.ജെഎസ് (Node.js) വന്നതോടെ, കൂടുതൽ കരുത്തുറ്റ ഒരു സെർവർ-സൈഡ് മൊഡ്യൂൾ സിസ്റ്റത്തിൻ്റെ ആവശ്യം അടിയന്തിരമായി. സെർവർ-സൈഡ് ആപ്ലിക്കേഷനുകൾക്ക് ഫയൽ സിസ്റ്റത്തിൽ നിന്ന് വിശ്വസനീയമായും സിൻക്രണസ് ആയും മൊഡ്യൂളുകൾ ലോഡ് ചെയ്യേണ്ടതുണ്ടായിരുന്നു. ഇത് കോമൺജെഎസ് (CJS)-ൻ്റെ സൃഷ്ടിയിലേക്ക് നയിച്ചു.

കോമൺജെഎസ് നോഡ്.ജെഎസ്-ൻ്റെ ഡി ഫാക്റ്റോ സ്റ്റാൻഡേർഡായി മാറി, ഇന്നും അതിൻ്റെ ആവാസവ്യവസ്ഥയുടെ ഒരു ആണിക്കല്ലായി തുടരുന്നു. അതിൻ്റെ രൂപകൽപ്പന ലളിതവും, സിൻക്രണസും, പ്രായോഗികവുമാണ്.

കോമൺജെഎസ്-ൻ്റെ പ്രധാന ആശയങ്ങൾ

• `require` ഫംഗ്ഷൻ: ഒരു മൊഡ്യൂൾ ഇംപോർട്ട് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഇത് മൊഡ്യൂൾ ഫയൽ വായിക്കുകയും, എക്സിക്യൂട്ട് ചെയ്യുകയും, `exports` ഒബ്ജക്റ്റ് തിരികെ നൽകുകയും ചെയ്യുന്നു. ഈ പ്രക്രിയ സിൻക്രണസ് ആണ്, അതായത് മൊഡ്യൂൾ ലോഡ് ആകുന്നത് വരെ എക്സിക്യൂഷൻ താൽക്കാലികമായി നിർത്തുന്നു.
• `module.exports` ഒബ്ജക്റ്റ്: ഒരു മൊഡ്യൂളിന് പബ്ലിക് ആക്കാൻ ആഗ്രഹിക്കുന്നതെല്ലാം അടങ്ങുന്ന ഒരു പ്രത്യേക ഒബ്ജക്റ്റ്. ഡിഫോൾട്ടായി, ഇത് ഒരു ശൂന്യമായ ഒബ്ജക്റ്റാണ്. നിങ്ങൾക്ക് ഇതിലേക്ക് പ്രോപ്പർട്ടികൾ ചേർക്കാനോ അല്ലെങ്കിൽ അതിനെ പൂർണ്ണമായും മാറ്റിസ്ഥാപിക്കാനോ കഴിയും.
• `exports` വേരിയബിൾ: `module.exports`-ലേക്കുള്ള ഒരു ഷോർട്ട്‌ഹാൻഡ് റഫറൻസ്. നിങ്ങൾക്ക് പ്രോപ്പർട്ടികൾ ചേർക്കാൻ ഇത് ഉപയോഗിക്കാം (ഉദാ: `exports.myFunction = ...`), എന്നാൽ ഇത് പുനർനിയമിക്കാൻ കഴിയില്ല (ഉദാ: `exports = ...`), കാരണം ഇത് `module.exports`-ലേക്കുള്ള റഫറൻസ് തകർക്കും.
• ഫയൽ-ബേസ്ഡ് മൊഡ്യൂളുകൾ: CJS-ൽ, ഓരോ ഫയലും അതിൻ്റേതായ പ്രൈവറ്റ് സ്കോപ്പുള്ള ഒരു മൊഡ്യൂളാണ്.

കോമൺജെഎസ് പ്രായോഗികമായി

ഒരു സാധാരണ നോഡ്.ജെഎസ് ഉദാഹരണം നോക്കാം.

`math.js` (ദി മൊഡ്യൂൾ)

            // A private function, not exported
const logOperation = (op, a, b) => {
  console.log(`Performing operation: ${op} on ${a} and ${b}`);
};

function add(a, b) {
  logOperation('add', a, b);
  return a + b;
}

function subtract(a, b) {
  logOperation('subtract', a, b);
  return a - b;
}

// Exporting the public functions
module.exports = {
  add: add,
  subtract: subtract
};
            

              
                Copy
              
            
          

`app.js` (ഉപഭോക്താവ്)

            // Importing the math module
const math = require('./math.js');

const sum = math.add(10, 5); // 15
const difference = math.subtract(10, 5); // 5

console.log(`The sum is ${sum}`);
console.log(`The difference is ${difference}`);
            

              
                Copy
              
            
          

`require`-ൻ്റെ സിൻക്രണസ് സ്വഭാവം സെർവറിന് ഏറ്റവും അനുയോജ്യമായിരുന്നു. ഒരു സെർവർ ആരംഭിക്കുമ്പോൾ, അതിന് ആവശ്യമായ എല്ലാ ഡിപൻഡൻസികളും ലോക്കൽ ഡിസ്കിൽ നിന്ന് വേഗത്തിലും പ്രവചനാതീതമായും ലോഡ് ചെയ്യാൻ കഴിയും. എന്നിരുന്നാലും, ഈ സിൻക്രണസ് സ്വഭാവം ബ്രൗസറുകൾക്ക് ഒരു വലിയ പ്രശ്നമായിരുന്നു, കാരണം വേഗത കുറഞ്ഞ നെറ്റ്‌വർക്കിലൂടെ ഒരു സ്ക്രിപ്റ്റ് ലോഡ് ചെയ്യുന്നത് മുഴുവൻ യൂസർ ഇൻ്റർഫേസും മരവിപ്പിക്കാൻ ഇടയാക്കും.

ബ്രൗസറിനായുള്ള പരിഹാരം: അസിൻക്രണസ് മൊഡ്യൂൾ ഡെഫനിഷൻ (AMD)

ബ്രൗസറുകളിലെ മൊഡ്യൂളുകളുടെ വെല്ലുവിളികളെ അഭിസംബോധന ചെയ്യാൻ, മറ്റൊരു സ്റ്റാൻഡേർഡ് ഉയർന്നു വന്നു: അസിൻക്രണസ് മൊഡ്യൂൾ ഡെഫനിഷൻ (AMD). ബ്രൗസറിൻ്റെ പ്രധാന ത്രെഡ് ബ്ലോക്ക് ചെയ്യാതെ, മൊഡ്യൂളുകൾ അസിൻക്രണസായി ലോഡ് ചെയ്യുക എന്നതാണ് AMD-യുടെ പ്രധാന തത്വം.

AMD-യുടെ ഏറ്റവും ജനപ്രിയമായ നടപ്പാക്കൽ RequireJS ലൈബ്രറിയായിരുന്നു. AMD-യുടെ സിൻടാക്സ് ഡിപൻഡൻസികളെക്കുറിച്ച് കൂടുതൽ വ്യക്തത നൽകുന്നു, കൂടാതെ ഒരു ഫംഗ്ഷൻ-റാപ്പർ ഫോർമാറ്റ് ഉപയോഗിക്കുന്നു.

AMD-യുടെ പ്രധാന ആശയങ്ങൾ

• `define` ഫംഗ്ഷൻ: ഒരു മൊഡ്യൂൾ നിർവചിക്കാൻ ഉപയോഗിക്കുന്നു. ഇത് ഡിപൻഡൻസികളുടെ ഒരു അറേയും ഒരു ഫാക്ടറി ഫംഗ്ഷനും എടുക്കുന്നു.
• അസിൻക്രണസ് ലോഡിംഗ്: മൊഡ്യൂൾ ലോഡർ (RequireJS പോലെ) പശ്ചാത്തലത്തിൽ ലിസ്റ്റുചെയ്ത എല്ലാ ഡിപൻഡൻസി സ്ക്രിപ്റ്റുകളും ലഭ്യമാക്കുന്നു.
• ഫാക്ടറി ഫംഗ്ഷൻ: എല്ലാ ഡിപൻഡൻസികളും ലോഡ് ചെയ്തുകഴിഞ്ഞാൽ, ലോഡുചെയ്ത മൊഡ്യൂളുകൾ ആർഗ്യുമെൻ്റുകളായി നൽകി ഫാക്ടറി ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഈ ഫംഗ്ഷൻ്റെ റിട്ടേൺ മൂല്യം മൊഡ്യൂളിൻ്റെ എക്സ്പോർട്ട് ചെയ്ത മൂല്യമായി മാറുന്നു.

AMD പ്രായോഗികമായി

നമ്മുടെ ഗണിത ഉദാഹരണം AMD, RequireJS ഉപയോഗിച്ച് എങ്ങനെയായിരിക്കുമെന്ന് നോക്കാം.

`math.js` (ദി മൊഡ്യൂൾ)

            define(function() {
  // This module has no dependencies

  const logOperation = (op, a, b) => {
    console.log(`Performing operation: ${op} on ${a} and ${b}`);
  };

  // Return the public API
  return {
    add: function(a, b) {
      logOperation('add', a, b);
      return a + b;
    },
    subtract: function(a, b) {
      logOperation('subtract', a, b);
      return a - b;
    }
  };
});
            

              
                Copy
              
            
          

`app.js` (ഉപഭോക്താവ്)

            define(['./math'], function(math) {
  // This code runs only after 'math.js' has been loaded

  const sum = math.add(10, 5);
  const difference = math.subtract(10, 5);

  console.log(`The sum is ${sum}`);
  console.log(`The difference is ${difference}`);

  // Typically you would use this to bootstrap your application
  document.getElementById('result').innerText = `Sum: ${sum}`;
});
            

              
                Copy
              
            
          

AMD ബ്ലോക്കിംഗ് പ്രശ്നം പരിഹരിച്ചെങ്കിലും, അതിൻ്റെ സിൻടാക്സ് പലപ്പോഴും കോമൺജെഎസിനേക്കാൾ കൂടുതൽ വാചാലവും അവബോധജന്യമല്ലാത്തതുമാണെന്ന് വിമർശിക്കപ്പെട്ടു. ഡിപൻഡൻസി അറേയുടെയും കോൾബാക്ക് ഫംഗ്ഷൻ്റെയും ആവശ്യം പല ഡെവലപ്പർമാർക്കും ബുദ്ധിമുട്ടായി തോന്നുന്ന ബോയിലർപ്ലേറ്റ് കോഡ് ചേർത്തു.

ഏകീകാരകൻ: യൂണിവേഴ്സൽ മൊഡ്യൂൾ ഡെഫനിഷൻ (UMD)

രണ്ട് ജനപ്രിയവും എന്നാൽ പൊരുത്തമില്ലാത്തതുമായ മൊഡ്യൂൾ സിസ്റ്റങ്ങൾ (സെർവറിനായി CJS, ബ്രൗസറിനായി AMD) നിലവിലുണ്ടായിരുന്നതിനാൽ, ഒരു പുതിയ പ്രശ്നം ഉയർന്നുവന്നു. രണ്ട് പരിതസ്ഥിതികളിലും പ്രവർത്തിക്കുന്ന ഒരു ലൈബ്രറി എങ്ങനെ എഴുതാം? ഇതിനുള്ള ഉത്തരമായിരുന്നു യൂണിവേഴ്സൽ മൊഡ്യൂൾ ഡെഫനിഷൻ (UMD) പാറ്റേൺ.

UMD ഒരു പുതിയ മൊഡ്യൂൾ സിസ്റ്റമല്ല, മറിച്ച് വ്യത്യസ്ത മൊഡ്യൂൾ ലോഡറുകളുടെ സാന്നിധ്യം പരിശോധിക്കാൻ ഒരു മൊഡ്യൂളിനെ പൊതിയുന്ന ഒരു സമർത്ഥമായ പാറ്റേണാണ്. ഇത് അടിസ്ഥാനപരമായി ഇങ്ങനെ പറയുന്നു: "ഒരു AMD ലോഡർ ഉണ്ടെങ്കിൽ, അത് ഉപയോഗിക്കുക. അല്ലെങ്കിൽ, ഒരു കോമൺജെഎസ് പരിതസ്ഥിതി ഉണ്ടെങ്കിൽ, അത് ഉപയോഗിക്കുക. അവസാന ആശ്രയമെന്ന നിലയിൽ, മൊഡ്യൂളിനെ ഒരു ഗ്ലോബൽ വേരിയബിളിലേക്ക് അസൈൻ ചെയ്യുക."

ഒരു UMD റാപ്പർ ഇതുപോലുള്ള ഒരു ബോയിലർപ്ലേറ്റ് കോഡാണ്:

            (function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        // AMD. Register as an anonymous module.
        define([], factory);
    } else if (typeof module === 'object' && module.exports) {
        // Node. CJS-like environments that support module.exports.
        module.exports = factory();
    } else {
        // Browser globals (root is window).
        root.myModuleName = factory();
    }
}(typeof self !== 'undefined' ? self : this, function () {
    // The actual module code goes here.
    const myApi = {};
    myApi.doSomething = function() { /* ... */ };
    return myApi;
}));
            

              
                Copy
              
            
          

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

ഔദ്യോഗിക സ്റ്റാൻഡേർഡ്: എക്മാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകൾ (ESM)

ഒടുവിൽ, എക്മാസ്ക്രിപ്റ്റ് 2015 (ES6) പുറത്തിറങ്ങിയതോടെ, ജാവാസ്ക്രിപ്റ്റിന് അതിൻ്റേതായ നേറ്റീവ് മൊഡ്യൂൾ സിസ്റ്റം ലഭിച്ചു. എക്മാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകൾ (ESM) രണ്ട് ലോകങ്ങളിലെയും മികച്ചത് നൽകാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്: കോമൺജെഎസ് പോലെയുള്ള വൃത്തിയുള്ളതും ഡിക്ലറേറ്റീവുമായ സിൻടാക്സും, ബ്രൗസറുകൾക്ക് അനുയോജ്യമായ അസിൻക്രണസ് ലോഡിംഗിനുള്ള പിന്തുണയും. ബ്രൗസറുകളിലും നോഡ്.ജെഎസിലും ESM-ന് പൂർണ്ണ പിന്തുണ ലഭിക്കാൻ കുറച്ച് വർഷങ്ങളെടുത്തു, എന്നാൽ ഇന്ന് മോഡുലാർ ജാവാസ്ക്രിപ്റ്റ് എഴുതാനുള്ള ഔദ്യോഗികവും സ്റ്റാൻഡേർഡുമായ മാർഗ്ഗം ഇതാണ്.

എക്മാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകളുടെ പ്രധാന ആശയങ്ങൾ

• `export` കീവേഡ്: മൊഡ്യൂളിന് പുറത്തുനിന്നും ആക്സസ് ചെയ്യേണ്ട മൂല്യങ്ങൾ, ഫംഗ്ഷനുകൾ, അല്ലെങ്കിൽ ക്ലാസുകൾ ഡിക്ലയർ ചെയ്യാൻ ഉപയോഗിക്കുന്നു.
• `import` കീവേഡ്: മറ്റൊരു മൊഡ്യൂളിൽ നിന്ന് എക്സ്പോർട്ട് ചെയ്ത അംഗങ്ങളെ നിലവിലെ സ്കോപ്പിലേക്ക് കൊണ്ടുവരാൻ ഉപയോഗിക്കുന്നു.
• സ്റ്റാറ്റിക് ഘടന: ESM സ്റ്റാറ്റിക്കായി വിശകലനം ചെയ്യാൻ കഴിയുന്നതാണ്. ഇതിനർത്ഥം, കോഡ് പ്രവർത്തിപ്പിക്കാതെ തന്നെ, സോഴ്സ് കോഡ് നോക്കി കംപൈൽ സമയത്ത് ഇംപോർട്ടുകളും എക്സ്പോർട്ടുകളും നിർണ്ണയിക്കാൻ കഴിയും. ട്രീ-ഷേക്കിംഗ് പോലുള്ള ശക്തമായ ടൂളുകൾക്ക് ഇത് ഒരു നിർണായക സവിശേഷതയാണ്.
• ഡിഫോൾട്ടായി അസിൻക്രണസ്: ESM-ൻ്റെ ലോഡിംഗും എക്സിക്യൂഷനും ജാവാസ്ക്രിപ്റ്റ് എഞ്ചിൻ നിയന്ത്രിക്കുന്നു, ഇത് നോൺ-ബ്ലോക്കിംഗ് ആയിട്ടാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.
• മൊഡ്യൂൾ സ്കോപ്പ്: CJS പോലെ, ഓരോ ഫയലും അതിൻ്റേതായ പ്രൈവറ്റ് സ്കോപ്പുള്ള ഒരു മൊഡ്യൂളാണ്.

ESM സിൻടാക്സ്: നെയിംഡ്, ഡിഫോൾട്ട് എക്സ്പോർട്ടുകൾ

ESM ഒരു മൊഡ്യൂളിൽ നിന്ന് എക്സ്പോർട്ട് ചെയ്യാൻ പ്രധാനമായും രണ്ട് വഴികൾ നൽകുന്നു: നെയിംഡ് എക്സ്പോർട്ടുകളും ഒരു ഡിഫോൾട്ട് എക്സ്പോർട്ടും.

നെയിംഡ് എക്സ്പോർട്ടുകൾ

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

`utils.js`

            export const PI = 3.14159;

export function formatDate(date) {
  return date.toLocaleDateString('en-US');
}

export class Logger {
  constructor(name) {
    this.name = name;
  }
  log(message) {
    console.log(`[${this.name}] ${message}`);
  }
}
            

              
                Copy
              
            
          

ഇവ ഇംപോർട്ട് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് ആവശ്യമുള്ള അംഗങ്ങളെ വ്യക്തമാക്കാൻ ചുരുണ്ട ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുക.

`main.js`

            import { PI, formatDate, Logger } from './utils.js';
// You can also rename imports
// import { PI as piValue } from './utils.js';

console.log(PI);
const logger = new Logger('App');
logger.log(`Today is ${formatDate(new Date())}`);
            

              
                Copy
              
            
          

ഡിഫോൾട്ട് എക്സ്പോർട്ട്

ഒരു മൊഡ്യൂളിന് ഒരു ഡിഫോൾട്ട് എക്സ്പോർട്ട് മാത്രമേ ഉണ്ടാകാൻ പാടുള്ളൂ. ഒരു മൊഡ്യൂളിൻ്റെ പ്രധാന ലക്ഷ്യം ഒരൊറ്റ ക്ലാസ് അല്ലെങ്കിൽ ഫംഗ്ഷൻ എക്സ്പോർട്ട് ചെയ്യുക എന്നതാണെങ്കിൽ ഇത് പലപ്പോഴും ഉപയോഗിക്കുന്നു.

`Calculator.js`

            export default class Calculator {
  add(a, b) {
    return a + b;
  }
  subtract(a, b) {
    return a - b;
  }
}

            

              
                Copy
              
            
          

ഒരു ഡിഫോൾട്ട് എക്സ്പോർട്ട് ഇംപോർട്ട് ചെയ്യുമ്പോൾ ചുരുണ്ട ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുന്നില്ല, കൂടാതെ ഇംപോർട്ട് ചെയ്യുമ്പോൾ നിങ്ങൾക്ക് ഇഷ്ടമുള്ള പേര് നൽകാം.

`main.js`

            import MyCalc from './Calculator.js';
// The name 'MyCalc' is arbitrary; `import Calc from ...` would also work.

const calculator = new MyCalc();
console.log(calculator.add(5, 3)); // 8
            

              
                Copy
              
            
          

ബ്രൗസറുകളിൽ ESM ഉപയോഗിക്കുന്നത്

ഒരു വെബ് ബ്രൗസറിൽ ESM ഉപയോഗിക്കുന്നതിന്, നിങ്ങളുടെ <script> ടാഗിൽ `type="module"` ചേർത്താൽ മതി.

            <!-- index.html -->
<script type="module" src="./main.js"></script>
            

              
                Copy
              
            
          

`type="module"` ഉള്ള സ്ക്രിപ്റ്റുകൾ ഓട്ടോമാറ്റിക്കായി ഡിഫർ ചെയ്യപ്പെടും, അതായത് HTML പാഴ്സിംഗിന് സമാന്തരമായി അവ ഫെച്ച് ചെയ്യുകയും ഡോക്യുമെൻ്റ് പൂർണ്ണമായി പാഴ്സ് ചെയ്തതിനുശേഷം മാത്രം എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യും. അവ ഡിഫോൾട്ടായി സ്ട്രിക്റ്റ് മോഡിലും പ്രവർത്തിക്കുന്നു.

നോഡ്.ജെഎസിലെ ESM: പുതിയ സ്റ്റാൻഡേർഡ്

കോമൺജെഎസിൽ ആഴത്തിൽ വേരൂന്നിയ ആവാസവ്യവസ്ഥ കാരണം ESM-നെ നോഡ്.ജെഎസിലേക്ക് സംയോജിപ്പിക്കുന്നത് ഒരു വലിയ വെല്ലുവിളിയായിരുന്നു. ഇന്ന്, നോഡ്.ജെഎസിന് ESM-ന് ശക്തമായ പിന്തുണയുണ്ട്. ഒരു ഫയലിനെ ES മൊഡ്യൂളായി പരിഗണിക്കാൻ നോഡ്.ജെഎസിനോട് പറയാൻ, നിങ്ങൾക്ക് രണ്ടിലൊന്ന് ചെയ്യാം:

1. ഫയലിന് `.mjs` എക്സ്റ്റൻഷൻ നൽകുക.
2. നിങ്ങളുടെ `package.json` ഫയലിൽ, `"type": "module"` എന്ന ഫീൽഡ് ചേർക്കുക. ഇത് ആ പ്രോജക്റ്റിലെ എല്ലാ `.js` ഫയലുകളെയും ES മൊഡ്യൂളുകളായി പരിഗണിക്കാൻ നോഡ്.ജെഎസിനോട് പറയുന്നു. നിങ്ങൾ ഇത് ചെയ്യുകയാണെങ്കിൽ, കോമൺജെഎസ് ഫയലുകൾക്ക് `.cjs` എക്സ്റ്റൻഷൻ നൽകി ഉപയോഗിക്കാം.

ഈ രണ്ട് സിസ്റ്റങ്ങൾക്കിടയിൽ ഇംപോർട്ടിംഗ് സിൻടാക്സ് കാര്യമായി വ്യത്യാസപ്പെട്ടിരിക്കുന്നതിനാൽ, ഒരു ഫയലിനെ എങ്ങനെ വ്യാഖ്യാനിക്കണമെന്ന് നോഡ്.ജെഎസ് റൺടൈമിന് അറിയാൻ ഈ വ്യക്തമായ കോൺഫിഗറേഷൻ ആവശ്യമാണ്.

വലിയ വിഭജനം: CJS vs. ESM പ്രായോഗികമായി

ESM ഭാവിയാണെങ്കിലും, കോമൺജെഎസ് ഇപ്പോഴും നോഡ്.ജെഎസ് ആവാസവ്യവസ്ഥയിൽ ആഴത്തിൽ വേരൂന്നിയതാണ്. വർഷങ്ങളോളം, ഡെവലപ്പർമാർക്ക് രണ്ട് സിസ്റ്റങ്ങളെയും അവ എങ്ങനെ ഇടപഴകുന്നുവെന്നും മനസ്സിലാക്കേണ്ടിവരും. ഇതിനെ പലപ്പോഴും "ഡ്യുവൽ പാക്കേജ് ഹസാർഡ്" എന്ന് വിളിക്കുന്നു.

പ്രധാന പ്രായോഗിക വ്യത്യാസങ്ങളുടെ ഒരു സംഗ്രഹം ഇതാ:

ഇൻ്റർഓപ്പറബിളിറ്റി: ലോകങ്ങൾക്കിടയിലുള്ള പാലം

ഒരു ESM ഫയലിൽ CJS മൊഡ്യൂളുകൾ ഉപയോഗിക്കാമോ, അല്ലെങ്കിൽ തിരിച്ചും? അതെ, എന്നാൽ ചില പ്രധാനപ്പെട്ട കാര്യങ്ങൾ ശ്രദ്ധിക്കാനുണ്ട്.

• CJS-നെ ESM-ലേക്ക് ഇംപോർട്ട് ചെയ്യുമ്പോൾ: നിങ്ങൾക്ക് ഒരു കോമൺജെഎസ് മൊഡ്യൂളിനെ ഒരു ES മൊഡ്യൂളിലേക്ക് ഇംപോർട്ട് ചെയ്യാം. നോഡ്.ജെഎസ് CJS മൊഡ്യൂളിനെ റാപ്പ് ചെയ്യും, സാധാരണയായി നിങ്ങൾക്ക് അതിൻ്റെ എക്സ്പോർട്ടുകൾ ഒരു ഡിഫോൾട്ട് ഇംപോർട്ട് വഴി ആക്സസ് ചെയ്യാൻ കഴിയും.

            // in an ESM file (e.g., index.mjs)
import legacyLib from './legacy-lib.cjs'; // CJS file

legacyLib.doSomething();

            

              
                Copy
              
            
          

• CJS-ൽ നിന്ന് ESM ഉപയോഗിക്കുമ്പോൾ: ഇത് കുറച്ചുകൂടി സങ്കീർണ്ണമാണ്. ഒരു ES മൊഡ്യൂൾ ഇംപോർട്ട് ചെയ്യാൻ നിങ്ങൾക്ക് `require()` ഉപയോഗിക്കാൻ കഴിയില്ല. `require()`-ൻ്റെ സിൻക്രണസ് സ്വഭാവം ESM-ൻ്റെ അസിൻക്രണസ് സ്വഭാവവുമായി അടിസ്ഥാനപരമായി പൊരുത്തപ്പെടുന്നില്ല. പകരം, നിങ്ങൾ ഡൈനാമിക് `import()` ഫംഗ്ഷൻ ഉപയോഗിക്കണം, അത് ഒരു പ്രോമിസ് (Promise) തിരികെ നൽകുന്നു.

            // in a CJS file (e.g., index.js)
async function loadEsModule() {
  const esModule = await import('./my-module.mjs');
  esModule.default.doSomething();
}

loadEsModule();

            

              
                Copy
              
            
          

ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകളുടെ ഭാവി: അടുത്തതെന്ത്?

ESM-ൻ്റെ സ്റ്റാൻഡേർഡൈസേഷൻ ഒരു സ്ഥിരതയുള്ള അടിത്തറ സൃഷ്ടിച്ചു, എന്നാൽ പരിണാമം അവസാനിച്ചിട്ടില്ല. നിരവധി ആധുനിക സവിശേഷതകളും നിർദ്ദേശങ്ങളും മൊഡ്യൂളുകളുടെ ഭാവിയെ രൂപപ്പെടുത്തുന്നു.

ഡൈനാമിക് `import()`

ഇതിനകം ഭാഷയുടെ ഒരു സ്റ്റാൻഡേർഡ് ഭാഗമായ `import()` ഫംഗ്ഷൻ, ആവശ്യാനുസരണം മൊഡ്യൂളുകൾ ലോഡ് ചെയ്യാൻ അനുവദിക്കുന്നു. വെബ് ആപ്ലിക്കേഷനുകളിൽ കോഡ്-സ്പ്ലിറ്റിംഗിന് ഇത് വളരെ ശക്തമാണ്, അവിടെ നിങ്ങൾ ഒരു പ്രത്യേക റൂട്ടിനോ അല്ലെങ്കിൽ ഉപയോക്താവിൻ്റെ പ്രവർത്തനത്തിനോ ആവശ്യമായ കോഡ് മാത്രം ലോഡ് ചെയ്യുന്നു, ഇത് പ്രാരംഭ ലോഡ് സമയം മെച്ചപ്പെടുത്തുന്നു.

            const button = document.getElementById('load-chart-btn');

button.addEventListener('click', async () => {
  // Load the charting library only when the user clicks the button
  const { Chart } = await import('./charting-library.js');
  const myChart = new Chart(/* ... */);
  myChart.render();
});
            

              
                Copy
              
            
          

ടോപ്പ്-ലെവൽ `await`

അടുത്തിടെ വന്നതും ശക്തവുമായ ഒരു കൂട്ടിച്ചേർക്കലാണ് ടോപ്പ്-ലെവൽ `await`. ഇത് ഒരു `async` ഫംഗ്ഷന് പുറത്ത് `await` കീവേഡ് ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, എന്നാൽ ഒരു ES മൊഡ്യൂളിൻ്റെ ടോപ്പ് ലെവലിൽ മാത്രം. ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഒരു അസിൻക്രണസ് ഓപ്പറേഷൻ (കോൺഫിഗറേഷൻ ഡാറ്റ ലഭ്യമാക്കുകയോ അല്ലെങ്കിൽ ഡാറ്റാബേസ് കണക്ഷൻ ആരംഭിക്കുകയോ പോലുള്ളവ) നടത്തേണ്ട മൊഡ്യൂളുകൾക്ക് ഇത് ഉപയോഗപ്രദമാണ്.

            // config.js
const response = await fetch('https://api.example.com/config');
const configData = await response.json();

export const config = configData;

// another-module.js
import { config } from './config.js'; // This module will wait for config.js to resolve

console.log(config.apiKey);

            

              
                Copy
              
            
          

ഇംപോർട്ട് മാപ്പുകൾ

ജാവാസ്ക്രിപ്റ്റ് ഇംപോർട്ടുകളുടെ സ്വഭാവം നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ബ്രൗസർ സവിശേഷതയാണ് ഇംപോർട്ട് മാപ്പുകൾ. "ബെയർ സ്പെസിഫയറുകൾ" (ഉദാഹരണത്തിന് `import moment from 'moment'`) ബിൽഡ് സ്റ്റെപ്പ് ഇല്ലാതെ നേരിട്ട് ബ്രൗസറിൽ ഉപയോഗിക്കാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു, ആ സ്പെസിഫയറിനെ ഒരു പ്രത്യേക URL-ലേക്ക് മാപ്പ് ചെയ്തുകൊണ്ട്.

            <!-- index.html -->
<script type="importmap">
{
  "imports": {
    "moment": "/node_modules/moment/dist/moment.js",
    "lodash": "https://unpkg.com/lodash-es@4.17.21/lodash.js"
  }
}
</script>

<script type="module">
  import moment from 'moment';
  import { debounce } from 'lodash';
  // The browser now knows where to find 'moment' and 'lodash'
</script>
            

              
                Copy
              
            
          

ഒരു ആഗോള ഡെവലപ്പർക്കുള്ള പ്രായോഗിക ഉപദേശങ്ങളും മികച്ച പരിശീലനങ്ങളും

1. പുതിയ പ്രോജക്റ്റുകൾക്ക് ESM സ്വീകരിക്കുക: ഏതൊരു പുതിയ വെബ് അല്ലെങ്കിൽ നോഡ്.ജെഎസ് പ്രോജക്റ്റിനും, ESM നിങ്ങളുടെ ഡിഫോൾട്ട് ചോയിസ് ആയിരിക്കണം. അത് ഭാഷാ സ്റ്റാൻഡേർഡാണ്, മികച്ച ടൂളിംഗ് പിന്തുണ നൽകുന്നു (പ്രത്യേകിച്ച് ട്രീ-ഷേക്കിംഗിനായി), കൂടാതെ ഭാഷയുടെ ഭാവി അതാണ്.
2. നിങ്ങളുടെ എൻവയോൺമെൻ്റ് മനസ്സിലാക്കുക: നിങ്ങളുടെ റൺടൈം ഏത് മൊഡ്യൂൾ സിസ്റ്റത്തെയാണ് പിന്തുണയ്ക്കുന്നതെന്ന് അറിയുക. ആധുനിക ബ്രൗസറുകൾക്കും നോഡ്.ജെഎസിൻ്റെ പുതിയ പതിപ്പുകൾക്കും മികച്ച ESM പിന്തുണയുണ്ട്. പഴയ എൻവയോൺമെൻ്റുകൾക്ക്, നിങ്ങൾക്ക് Babel പോലുള്ള ഒരു ട്രാൻസ്പൈലറും Webpack അല്ലെങ്കിൽ Rollup പോലുള്ള ഒരു ബണ്ട്ലറും ആവശ്യമായി വരും.
3. ഇൻ്റർഓപ്പറബിളിറ്റി ശ്രദ്ധിക്കുക: ഒരു മിക്സഡ് CJS/ESM കോഡ്‌ബേസിൽ പ്രവർത്തിക്കുമ്പോൾ (മൈഗ്രേഷനുകളിൽ സാധാരണമാണ്), രണ്ട് സിസ്റ്റങ്ങൾക്കിടയിലുള്ള ഇംപോർട്ടുകളും എക്സ്പോർട്ടുകളും എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്നതിനെക്കുറിച്ച് ബോധവാന്മാരായിരിക്കുക. ഓർക്കുക: CJS-ന് ESM ഉപയോഗിക്കാൻ ഡൈനാമിക് `import()` വഴി മാത്രമേ കഴിയൂ.
4. ആധുനിക ടൂളിംഗ് പ്രയോജനപ്പെടുത്തുക: Vite പോലുള്ള ആധുനിക ബിൽഡ് ടൂളുകൾ ESM മനസ്സിൽ വെച്ചുകൊണ്ടാണ് നിർമ്മിച്ചിരിക്കുന്നത്, ഇത് അവിശ്വസനീയമാംവിധം വേഗതയേറിയ ഡെവലപ്‌മെൻ്റ് സെർവറുകളും ഒപ്റ്റിമൈസ് ചെയ്ത ബിൽഡുകളും നൽകുന്നു. മൊഡ്യൂൾ റെസലൂഷൻ്റെയും ബണ്ട്ലിംഗിൻ്റെയും പല സങ്കീർണ്ണതകളും അവ ഒഴിവാക്കുന്നു.
5. ഒരു ലൈബ്രറി പ്രസിദ്ധീകരിക്കുമ്പോൾ: നിങ്ങളുടെ പാക്കേജ് ആരാണ് ഉപയോഗിക്കാൻ പോകുന്നതെന്ന് പരിഗണിക്കുക. ഇന്നത്തെ പല ലൈബ്രറികളും മുഴുവൻ ആവാസവ്യവസ്ഥയെയും പിന്തുണയ്ക്കുന്നതിനായി ഒരു ESM, ഒരു CJS പതിപ്പ് എന്നിവ പ്രസിദ്ധീകരിക്കുന്നു. `package.json`-ലെ `exports` ഫീൽഡ് വ്യത്യസ്ത എൻവയോൺമെൻ്റുകൾക്കായി കണ്ടീഷണൽ എക്സ്പോർട്ടുകൾ നിർവചിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഉപസംഹാരം: ഒരു ഏകീകൃത ഭാവി

ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകളുടെ യാത്ര കമ്മ്യൂണിറ്റി നൂതനാശയങ്ങളുടെയും പ്രായോഗിക പരിഹാരങ്ങളുടെയും ഒടുവിലത്തെ സ്റ്റാൻഡേർഡൈസേഷൻ്റെയും ഒരു കഥയാണ്. ഗ്ലോബൽ സ്കോപ്പിൻ്റെ ആദ്യകാല കുഴപ്പങ്ങളിൽ നിന്ന്, കോമൺജെഎസിൻ്റെ സെർവർ-സൈഡ് കാഠിന്യത്തിലൂടെയും AMD-യുടെ ബ്രൗസർ-കേന്ദ്രീകൃത അസിൻക്രണോസിറ്റിയിലൂടെയും, എക്മാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകളുടെ ഏകീകൃത ശക്തിയിലേക്കും, ഈ പാത ദൈർഘ്യമേറിയതാണെങ്കിലും മൂല്യവത്തായിരുന്നു.

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