Node.js ES Modules

நவீன JavaScript தொகுதி தரத்தை Node.js இல் கண்டறியவும்

ES தொகுதிகளுக்கு அறிமுகம்

ES தொகுதிகள் (ESM) மீண்டும் பயன்படுத்துவதற்காக JavaScript குறியீட்டை தொகுப்பதற்கான அதிகாரப்பூர்வ தரநிலை வடிவமாகும்.

இது ES6 (ES2015) இல் அறிமுகப்படுத்தப்பட்டது மற்றும் இப்போது Node.js இல் ஆதரிக்கப்படுகிறது.

ES தொகுதிகளுக்கு முன்பு, Node.js பிரத்தியேகமாக CommonJS தொகுதி வடிவத்தை (require/exports) பயன்படுத்தியது.

இப்போது டெவலப்பர்கள் அவர்களின் திட்டத் தேவைகளின் அடிப்படையில் CommonJS மற்றும் ES தொகுதிகளுக்கு இடையே தேர்வு செய்யலாம்.

கட்டமைக்கப்பட்ட தொடரியல்

CommonJS உடன் ஒப்பிடும்போது மேம்பட்ட கட்டமைப்பு

நிலையான பகுப்பாய்வு

நிலையான பகுப்பாய்வு செய்யக்கூடிய தொகுதிகள்

மர-குலுக்கல்

சிறிய கட்டுமானங்களுக்கான மர-குலுக்கல் ஆதரவு

CommonJS vs ES தொகுதிகள்

CommonJS மற்றும் ES தொகுதிகள் எவ்வாறு வேறுபடுகின்றன என்பது இங்கே:

அம்சம் CommonJS ES தொகுதிகள்
கோப்பு நீட்டிப்பு .js (இயல்புநிலை) .mjs (அல்லது சரியான கட்டமைப்புடன் .js)
இறக்குமதி தொடரியல் require() import
ஏற்றுமதி தொடரியல் module.exports / exports export / export default
இறக்குமதி நேரம் டைனமிக் (இயக்க நேரம்) நிலையான (இயக்கத்திற்கு முன் பாகுபடுத்தப்பட்டது)
மேல்-நிலை Await ஆதரிக்கப்படவில்லை ஆதரிக்கப்படுகிறது
இறக்குமதிகளில் கோப்பு URL தேவையில்லை உள்ளூர் கோப்புகளுக்கு தேவை

எடுத்துக்காட்டு: CommonJS தொகுதி

// math.js (CommonJS)
function add(a, b) {
  return a + b;
}

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

module.exports = {
  add,
  subtract
};

// app.js (CommonJS)
const math = require('./math');
console.log(math.add(5, 3)); // 8

எடுத்துக்காட்டு: ES தொகுதி

// math.mjs (ES Module)
export function add(a, b) {
  return a + b;
}

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

// app.mjs (ES Module)
import { add, subtract } from './math.mjs';
console.log(add(5, 3)); // 8

ES தொகுதிகளை இயக்குதல்

Node.js இல் ES தொகுதிகளை இயக்க பல வழிகள் உள்ளன:

1. .mjs கோப்பு நீட்டிப்பைப் பயன்படுத்துதல்

உங்கள் கோப்புகளுக்கு .mjs நீட்டிப்பைப் பயன்படுத்துவது எளிதான வழி.

Node.js இந்த கோப்புகளை தானாகவே ES தொகுதிகளாக கருதும்.

2. package.json இல் "type": "module" அமைத்தல்

வழக்கமான .js கோப்புகளுடன் ES தொகுதிகளைப் பயன்படுத்த, உங்கள் package.json க்கு பின்வருவனவற்றைச் சேர்க்கவும்:

{
  "name": "my-package",
  "version": "1.0.0",
  "type": "module"
}

3. --input-type=module கொடியைப் பயன்படுத்துதல்

node கட்டளையுடன் நேரடியாக இயக்கப்படும் ஸ்கிரிப்ட்களுக்கு, நீங்கள் தொகுதி அமைப்பைக் குறிப்பிடலாம்:

node --input-type=module script.js

💡 குறிப்பு:

நீங்கள் முதன்மையாக CommonJS ஐப் பயன்படுத்தும் குறியீட்டுத் தளத்துடன் பணிபுரிந்து, ஒரு கோப்பில் ES தொகுதிகளைப் பயன்படுத்த விரும்பினால், .mjs நீட்டிப்பைப் பயன்படுத்துவது மிகவும் வெளிப்படையான மற்றும் குறைந்த பிழை-ஏற்புடைய அணுகுமுறையாகும்.

இறக்குமதி மற்றும் ஏற்றுமதி தொடரியல்

ES தொகுதிகள் CommonJS உடன் ஒப்பிடும்போது குறியீட்டை இறக்குமதி செய்தல் மற்றும் ஏற்றுமதி செய்வதற்கான மேலும் நெகிழ்வான வழிகளை வழங்குகின்றன.

ஏற்றுமதி தொடரியல்

பெயரிடப்பட்ட ஏற்றுமதிகள்
// Multiple named exports
export function sayHello() {
  console.log('Hello');
}

export function sayGoodbye() {
  console.log('Goodbye');
}

// Alternative: export list at the end
function add(a, b) {
  return a + b;
}

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

export { add, subtract };
இயல்புநிலை ஏற்றுமதி
// Only one default export per module
export default function() {
  console.log('I am the default export');
}

// Or with a named function/class/object
function mainFunction() {
  return 'Main functionality';
}

export default mainFunction;

இறக்குமதி தொடரியல்

பெயரிடப்பட்ட ஏற்றுமதிகளை இறக்குமதி செய்தல்
// Import specific named exports
import { sayHello, sayGoodbye } from './greetings.mjs';
sayHello(); // Hello

// Rename imports to avoid naming conflicts
import { add as sum, subtract as minus } from './math.mjs';
console.log(sum(5, 3)); // 8

// Import all named exports as an object
import * as math from './math.mjs';
console.log(math.add(7, 4)); // 11
இயல்புநிலை மற்றும் பெயரிடப்பட்ட ஏற்றுமதிகளை இறக்குமதி செய்தல்
// Import both default and named exports
import main, { VERSION } from './main.mjs';
console.log(VERSION); // 1.0.0
main(); // Main function

டைனமிக் இறக்குமதிகள்

ES தொகுதிகள் டைனமிக் இறக்குமதிகளை ஆதரிக்கின்றன, இது நிபந்தனையுடன் அல்லது தேவைக்கேற்ப தொகுதிகளை ஏற்ற உங்களை அனுமதிக்கிறது.

எடுத்துக்காட்டு: டைனமிக் இறக்குமதிகள்

// app.mjs
async function loadModule(moduleName) {
  try {
    // Dynamic import returns a promise
    const module = await import(`./${moduleName}.mjs`);
    return module;
  } catch (error) {
    console.error(`Failed to load ${moduleName}:`, error);
  }
}

// Load a module based on a condition
const moduleName = process.env.NODE_ENV === 'production' ? 'prod' : 'dev';

loadModule(moduleName).then(module => {
  module.default(); // Call the default export
});

// Or with simpler await syntax
(async () => {
  const mathModule = await import('./math.mjs');
  console.log(mathModule.add(10, 5)); // 15
})();

🚀 பயன்பாட்டு வழக்கு:

டைனமிக் இறக்குமதிகள் குறியீடு-பிரித்தல், சோம்பலான-ஏற்றுதல் தொகுதிகள் அல்லது இயக்க நேர நிபந்தனைகளின் அடிப்படையில் நிபந்தனையுடன் தொகுதிகளை ஏற்றுவதற்கு சிறந்தவை.

மேல்-நிலை Await

CommonJS போலல்லாமல், ES தொகுதிகள் மேல்-நிலை await ஐ ஆதரிக்கின்றன, இது தொகுதி நிலையில் async செயல்பாடுகளுக்கு வெளியே await ஐப் பயன்படுத்த உங்களை அனுமதிக்கிறது.

எடுத்துக்காட்டு: மேல்-நிலை Await

// data-loader.mjs
// This would cause an error in CommonJS or in a script
// But works at the top level in an ES Module

console.log('Loading data...');

// Top-level await - the module's execution pauses here
const response = await fetch('https://jsonplaceholder.typicode.com/todos/1');
const data = await response.json();

console.log('Data loaded!');

export { data };

// When another module imports this one, it will only get the exports
// after all the top-level await operations have completed

கட்டமைப்பு ஏற்றுதல்

கோப்புகள் அல்லது தொலைதூர மூலங்களிலிருந்து கட்டமைப்பை ஏற்றுதல்

தரவுத்தள இணைப்புகள்

செயல்பாட்டை ஏற்றுமதி செய்வதற்கு முன் தரவுத்தளங்களுடன் இணைத்தல்

தொகுதி துவக்கம்

நிபந்தனை இறக்குமதிகள் அல்லது தொகுதி துவக்கம்

சிறந்த நடைமுறைகள்

Node.js இல் ES தொகுதிகளுடன் பணிபுரியும் போது, இந்த சிறந்த நடைமுறைகளைப் பின்பற்றவும்:

1. கோப்பு நீட்டிப்புகளைப் பற்றி தெளிவாக இருங்கள்

உள்ளூர் கோப்புகளுக்கான உங்கள் இறக்குமதி அறிக்கைகளில் எப்போதும் கோப்பு நீட்டிப்புகளைச் சேர்க்கவும்:

// Good
import { someFunction } from './utils.mjs';

// Bad - might not work depending on configuration
import { someFunction } from './utils';

2. கோப்புறை குறியீடுகளை சரியாகப் பயன்படுத்தவும்

கோப்புறை இறக்குமதிகளுக்கு, index.mjs கோப்புகளை உருவாக்கவும்:

// utils/index.mjs
export * from './string-utils.mjs';
export * from './number-utils.mjs';

// app.mjs
import { formatString, add } from './utils/index.mjs';

3. சரியான ஏற்றுமதி பாணியைத் தேர்ந்தெடுக்கவும்

பல செயல்பாடுகள்/மதிப்புகளுக்கு பெயரிடப்பட்ட ஏற்றுமதிகளைப் பயன்படுத்தவும், முக்கிய செயல்பாட்டிற்கு இயல்புநிலை ஏற்றுமதிகளைப் பயன்படுத்தவும்:

// For libraries with many utilities, use named exports
export function validate() { /* ... */ }
export function format() { /* ... */ }

// For components or classes that are the primary export
export default class UserService { /* ... */ }

💎 Node.js ஆதரவு:

ES தொகுதிகள் Node.js v12 இல் முழுமையாக ஆதரிக்கப்படுகின்றன, v14+ இல் சிறந்த ஆதரவு உள்ளது. பழைய பதிப்புகளுக்கு, உங்களுக்கு Babel போன்ற மொழிபெயர்ப்பான் தேவைப்படலாம்.

சுருக்கம்

.mjs நீட்டிப்பு

ES தொகுதிகளை இயக்க எளிதான வழி

import தொடரியல்

நிலையான பகுப்பாய்வு மற்றும் மர-குலுக்கல்

டைனமிக் இறக்குமதிகள்

நிபந்தனை தொகுதி ஏற்றுதல்

மேல்-நிலை await

தொகுதி நிலையில் நேரடி await ஆதரவு

🚀 முக்கிய புள்ளிகள்:

  • ES தொகுதிகள் நவீன JavaScript தொகுதி தரநிலையாகும்
  • CommonJS உடன் ஒப்பிடும்போது நிலையான பகுப்பாய்வு மற்றும் மர-குலுக்கல் ஆதரவு
  • டைனமிக் இறக்குமதிகள் குறியீடு-பிரித்தலுக்கு சிறந்தவை
  • மேல்-நிலை await தொகுதி துவக்கத்தை எளிதாக்குகிறது
  • கோப்பு நீட்டிப்புகள் மற்றும் ஏற்றுமதி பாணிகளில் தெளிவாக இருங்கள்

பயிற்சி

சரியான முக்கிய சொல்லை தேர்ந்தெடுக்கவும்.

ES தொகுதிகள் மற்ற தொகுதிகளை ஏற்ற ______ முக்கிய சொல்லைப் பயன்படுத்துகின்றன.

require
✗ தவறு! require CommonJS தொகுதிகளுக்குப் பயன்படுத்தப்படுகிறது, ES தொகுதிகளுக்கு அல்ல
import
✓ சரி! ES தொகுதிகள் மற்ற தொகுதிகளை இறக்குமதி செய்ய import முக்கிய சொல்லைப் பயன்படுத்துகின்றன
include
✗ தவறு! include என்பது JavaScript இல் தொகுதிகளை இறக்குமதி செய்ய பயன்படுத்தப்படும் முக்கிய சொல் அல்ல
load
✗ தவறு! load என்பது JavaScript இல் தொகுதிகளை இறக்குமதி செய்ய பயன்படுத்தப்படும் முக்கிய சொல் அல்ல