JavaScript
मॉडर्नाइजेशन तकनीक

यूनिवर्सल मॉड्यूल परिभाषा (UMD)

यूएमडी (यूनिवर्सल मॉड्यूल परिभाषा) पैटर्न का उपयोग तब किया जाता है जब हमारे मॉड्यूल को कई अलग-अलग मॉड्यूल लोडर (जैसे एएमडी, कॉमनजेएस) द्वारा आयात करने की आवश्यकता होती है।

पैटर्न में ही दो भाग होते हैं:

1. एक IIFE (तत्काल-इनवॉल्ड फंक्शन एक्सप्रेशन) जो उपयोगकर्ता द्वारा कार्यान्वित किए जा रहे मॉड्यूल लोडर के लिए जाँच करता है। यह दो तर्क लेगा; root (एक this वैश्विक विस्तार के संदर्भ में) और factory (समारोह जहां हम अपने मॉड्यूल घोषित)।

2. एक अनाम फ़ंक्शन जो हमारा मॉड्यूल बनाता है। इसे पैटर्न के IIFE भाग के दूसरे तर्क के रूप में पारित किया गया है। यह फ़ंक्शन मॉड्यूल की निर्भरता को निर्दिष्ट करने के लिए किसी भी संख्या में तर्क पारित किया जाता है।

नीचे दिए गए उदाहरण में हम एएमडी के लिए जांच करते हैं, फिर कॉमनजस। यदि उन लोडर में से कोई भी उपयोग में नहीं है, तो हम मॉड्यूल और इसकी निर्भरता को वैश्विक स्तर पर उपलब्ध कराने के लिए वापस आते हैं।

(function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        // AMD. Register as an anonymous module.
        define(['exports', 'b'], factory);
    } else if (typeof exports === 'object' && typeof exports.nodeName !== 'string') {
        // CommonJS
        factory(exports, require('b'));
    } else {
        // Browser globals
        factory((root.commonJsStrict = {}), root.b);
    }
}(this, function (exports, b) {
    //use b in some fashion.

    // attach properties to the exports object to define
    // the exported module properties.
    exports.action = function () {};
}));

तुरंत कार्य अभिव्यक्तियाँ (IIFE)

सार्वजनिक एपीआई का निर्माण करते समय एक त्वरित कार्य अभिव्यक्ति का उपयोग निजी दायरे बनाने के लिए किया जा सकता है।

var Module = (function() {
  var privateData = 1;

  return {
    getPrivateData: function() {
      return privateData;
    }
  };
})();
Module.getPrivateData(); // 1
Module.privateData; // undefined

अधिक विवरण के लिए मॉड्यूल पैटर्न देखें।

अतुल्यकालिक मॉड्यूल परिभाषा (AMD)

एएमडी एक मॉड्यूल परिभाषा प्रणाली है जो कॉमनजस और अनाम क्लोजर जैसी अन्य प्रणालियों के साथ कुछ सामान्य मुद्दों को संबोधित करने का प्रयास करती है।

AMD इन मुद्दों को संबोधित करता है:

• तुरंत निष्पादित करने के बजाय परिभाषित () को कॉल करके फ़ैक्टरी फ़ंक्शन को पंजीकृत करना
• मॉड्यूल नाम की एक सरणी के रूप में निर्भरता पारित करना, जो तब ग्लोबल्स का उपयोग करने के बजाय लोड किया जाता है
• एक बार सभी आश्रितों को लोड करने और निष्पादित करने के बाद ही कारखाने के कार्य को निष्पादित करना
• कारखाने के कार्य के लिए आश्रित मॉड्यूल को तर्क के रूप में पारित करना

यहां महत्वपूर्ण बात यह है कि एक मॉड्यूल में एक निर्भरता हो सकती है और इसे लोड करने के लिए इंतजार करते समय सब कुछ नहीं पकड़ सकता है, बिना डेवलपर को जटिल कोड लिखने के लिए।

यहाँ एएमडी का एक उदाहरण है:

// Define a module "myModule" with two dependencies, jQuery and Lodash
define("myModule", ["jquery", "lodash"], function($, _) {
    // This publicly accessible object is our module
    // Here we use an object, but it can be of any type
    var myModule = {};

    var privateVar = "Nothing outside of this module can see me";

    var privateFn = function(param) {
        return "Here's what you said: " + param;
    };

    myModule.version = 1;

    myModule.moduleMethod = function() {
        // We can still access global variables from here, but it's better
        // if we use the passed ones
        return privateFn(windowTitle);
    };

    return myModule;
});

मॉड्यूल भी नाम को छोड़ सकते हैं और गुमनाम हो सकते हैं। जब ऐसा किया जाता है, तो वे आमतौर पर फ़ाइल नाम से लोड होते हैं।

define(["jquery", "lodash"], function($, _) { /* factory */ });

वे निर्भरता को भी छोड़ सकते हैं:

define(function() { /* factory */ });

कुछ AMD लोडर सादे वस्तुओं के रूप में परिभाषित मॉड्यूल का समर्थन करते हैं:

define("myModule", { version: 1, value: "sample string" });

CommonJS - Node.js

CommonJS एक लोकप्रिय मॉडर्लाइज़ेशन पैटर्न है जिसका उपयोग Node.js. में किया जाता है।

कॉमनजेएस प्रणाली एक require() फ़ंक्शन के आसपास केंद्रित है जो अन्य मॉड्यूल और एक exports संपत्ति को लोड exports है जो मॉड्यूल को सार्वजनिक रूप से सुलभ तरीकों को निर्यात करने देता है।

यहां कॉमनजस का एक उदाहरण दिया गया है, हम लोडश और नोड्स के fs मॉड्यूल को लोड करेंगे:

// Load fs and lodash, we can use them anywhere inside the module
var fs = require("fs"),
    _ = require("lodash");

var myPrivateFn = function(param) {
    return "Here's what you said: " + param;
};

// Here we export a public `myMethod` that other modules can use
exports.myMethod = function(param) {
    return myPrivateFn(param);
};

आप मॉड्यूल. module.exports का उपयोग करके पूरे मॉड्यूल के रूप में एक फ़ंक्शन भी निर्यात कर सकते हैं:

module.exports = function() {
    return "Hello!";
};

ES6 मॉड्यूल

export function greet(name) {
    console.log("Hello %s!", name);
}

var myMethod = function(param) {
    return "Here's what you said: " + param;
};

export {myMethod}

export class MyClass {
    test() {}
}

import greet from "mymodule.js";

greet("Bob");

import * as myModule from "mymodule.js";

myModule.greet("Alice");

import { greet as A, myMethod as B } from "mymodule.js";

ES6 मॉड्यूल के बारे में अधिक जानकारी मॉड्यूल विषय में पाई जा सकती है।