බොහෝ දේ කියවීමෙන් පසුව පවා මම තවමත් පොදු ජේඑස් , ඒඑම්ඩී සහ රික්වයිජේඑස් ගැන ව්‍යාකූල වී සිටිමි .

CommonJS (කලින් ServerJS ) යනු බ්‍රව්සරයෙන් පිටත භාෂාව භාවිතා කරන විට සමහර ජාවාස්ක්‍රිප්ට් පිරිවිතරයන් (එනම් මොඩියුල) අර්ථ දැක්වීම සඳහා වූ කණ්ඩායමක් බව මම දනිමි . CommonJS මොඩියුල පිරිවිතරයන්ට Node.js හෝ RingoJS වැනි ක්‍රියාත්මක කිරීමක් තිබේ , නේද?

අතර සබඳතාවය කුමක්ද CommonJS , Asynchronous මොඩියුලය අර්ථ දැක්වීම (AMD) හා RequireJS ?

ය RequireJS එම ක ක්රියාත්මක CommonJS මොඩියුලය නිර්වචනය? එසේ නම්, AMD යනු කුමක්ද?

RequireJS විසින් AMD API (ප්‍රභවය) ක්‍රියාත්මක කරයි.

CommonJS යනු exportsමොඩියුලයේ අන්තර්ගතය නිර්වචනය කරන වස්තුවක ආධාරයෙන් මොඩියුල නිර්වචනය කිරීමේ ක්‍රමයකි . සරලව කිවහොත්, CommonJS ක්‍රියාත්මක කිරීම මේ ආකාරයෙන් ක්‍රියාත්මක විය හැකිය:

// someModule.js
exports.doSomething = function() { return "foo"; };

//otherModule.js
var someModule = require('someModule'); // in the vein of node    
exports.doSomethingElse = function() { return someModule.doSomething() + "bar"; };

මූලික වශයෙන්, require()පරායත්තතාවයන් ලබා ගැනීම සඳහා ශ්‍රිතයක්, exportsමොඩියුල අන්තර්ගතයන් අපනයනය කිරීමට විචල්‍යයක් සහ මොඩියුල හඳුනාගැනීමක් (මෙම මොඩියුලයට අදාළව මොඩියුලයේ පිහිටීම විස්තර කරන) පරායත්තතා ( ප්‍රභවය ) අවශ්‍ය බව පොදු ජේඑස් නියම කරයි. ). CommonJS හි ඔබ සඳහන් කළ Node.js ඇතුළු විවිධ ක්‍රියාත්මක කිරීම් තිබේ .

CommonJS විශේෂයෙන් නිර්මාණය කර ඇත්තේ බ්‍රව්සර් මනසේ තබාගෙන නොවේ, එබැවින් එය බ්‍රව්සර් පරිසරයට හොඳින් ගැලපෙන්නේ නැත ( මට ඇත්ත වශයෙන්ම මේ සඳහා ප්‍රභවයක් නොමැත - එය අවශ්‍ය වන්නේ JJ වෙබ් අඩවිය ඇතුළුව සෑම තැනකම ය . ) පෙනෙන විදිහට, මේ සඳහා යමක් තිබේ අසමමුහුර්ත පැටවීම ආදිය සමඟ කරන්න.

අනෙක් අතට, RequireJS විසින් AMD ක්‍රියාත්මක කරන අතර එය බ්‍රව්සර් පරිසරයට ( ප්‍රභවයට ) ගැලපෙන පරිදි නිර්මාණය කර ඇත . පෙනෙන විදිහට, AMD පොදු ජේඑස් ප්‍රවාහන ආකෘතියේ භ්‍රමණය වීමක් ලෙස ආරම්භ වී එහි මොඩියුල අර්ථ දැක්වීමේ API බවට පරිණාමය විය. එබැවින් දෙක අතර සමානකම්. AMD හි ඇති නව ලක්ෂණය වන්නේ define()පැටවීමට පෙර මොඩියුලයට එහි පරායත්තතා ප්‍රකාශ කිරීමට ඉඩ දෙන ශ්‍රිතයයි. උදාහරණයක් ලෙස, අර්ථ දැක්වීම විය හැක්කේ:

define('module/id/string', ['module', 'dependency', 'array'], 
function(module, factory function) {
  return ModuleContents;  
});

ඉතින්, CommonJS සහ AMD යනු විවිධ ක්‍රියාත්මක කිරීම් ඇති ජාවාස්ක්‍රිප්ට් මොඩියුල අර්ථ දැක්වීමේ API ය, නමුත් දෙකම එකම මූලාරම්භයකින් පැමිණේ.

• මොඩියුල පරායත්තතාවයන් අසමමුහුර්තව පැටවීමට සහාය වන නිසා AMD බ්‍රව්සරයට වඩාත් ගැලපේ.
• RequireJS ක ක්රියාත්මක වේ AMD එම අවස්ථාවේ දී බලය තබා ගැනීමට උත්සාහ කරන අතරේම, CommonJS (ප්රධාන වශයෙන් මෙම මොඩියුලය මඟින් හඳුනාගෙන ඇති).

ඔබව තව තවත් ව්‍යාකූල කිරීම සඳහා, RequireJS, AMD ක්‍රියාත්මක කිරීමක් වන අතර, CommonJS එතීම ඉදිරිපත් කරයි, එබැවින් CommonJS මොඩියුලයන් RequireJS සමඟ භාවිතා කිරීම සඳහා කෙලින්ම ආනයනය කළ හැකිය.

define(function(require, exports, module) {
  var someModule = require('someModule'); // in the vein of node    
  exports.doSomethingElse = function() { return someModule.doSomething() + "bar"; };
});

මෙය කරුණු පැහැදිලි කිරීමට උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි!

CommonJS ඊට වඩා වැඩි ය - එය ජාවාස්ක්‍රිප්ට් සඳහා පොදු API සහ පරිසර පද්ධතියක් නිර්වචනය කිරීමේ ව්‍යාපෘතියකි. CommonJS හි එක් කොටසක් වන්නේ මොඩියුල පිරිවිතරයි. Node.js සහ RingoJS යනු සේවාදායක පාර්ශවීය ජාවාස්ක්‍රිප්ට් ධාවන වේලාවන් වන අතර ඔව්, මේ දෙකම පොදු ජේඑස් මොඩියුල පිරිවිතර මත පදනම්ව මොඩියුල ක්‍රියාත්මක කරයි.

AMD (අසමමුහුර්ත මොඩියුල අර්ථ දැක්වීම) යනු මොඩියුල සඳහා තවත් පිරිවිතරයකි. RequireJS බොහෝ විට AMD හි වඩාත් ජනප්‍රිය ක්‍රියාත්මක කිරීම වේ. CommonJS වෙතින් ඇති එක් ප්‍රධාන වෙනසක් නම්, මොඩියුලයන් අසමමුහුර්තව පටවා ඇති බව AMD නියම කරයි - එයින් අදහස් වන්නේ බරක් අවසන් වන තෙක් බලා සිටීමෙන් ක්‍රියාත්මක කිරීම අවහිර කිරීමට වඩා මොඩියුල සමාන්තරව පටවන බවයි.

AMD සාමාන්‍යයෙන් සේවාදායක පාර්ශවයේ (බ්‍රව්සරයේ) ජාවාස්ක්‍රිප්ට් සංවර්ධනය සඳහා වැඩි වශයෙන් භාවිතා වන අතර පොදු ජේඑස් මොඩියුලයන් සාමාන්‍යයෙන් සේවාදායක පැත්තෙන් භාවිතා කරයි. කෙසේ වෙතත්, ඔබට ඕනෑම පරිසරයක මොඩියුල පිරිවිතර භාවිතා කළ හැකිය - නිදසුනක් ලෙස, RequireJS විසින් Node.js හි ධාවනය සඳහා උපදෙස් ලබා දෙන අතර බ්‍රව්සරකරණය යනු බ්‍රවුසරයේ ක්‍රියාත්මක කළ හැකි පොදු ජේඑස් මොඩියුල ක්‍රියාත්මක කිරීමකි.

කෙටි පිළිතුර වනුයේ:

CommonJS සහ AMD යනු ජාවාස්ක්‍රිප්ට් යෙදුම්වල මොඩියුල සහ ඒවායේ පරායත්තතා ප්‍රකාශ කළ යුතු ආකාරය පිළිබඳ පිරිවිතර (හෝ ආකෘති) වේ.

RequireJS යනු ස්ක්‍රිප්ට් ලෝඩර් පුස්තකාලයක් වන අතර එය AMD අනුකූල වේ, curljs තවත් උදාහරණයකි.

CommonJS අනුකූල:

සිට ගෙන Addy Osmani පොත .

// package/lib is a dependency we require
var lib = require( "package/lib" );

// behavior for our module
function foo(){
    lib.log( "hello world!" );
}

// export (expose) foo to other modules as foobar
exports.foobar = foo;

AMD අනුකූල:

// package/lib is a dependency we require
define(["package/lib"], function (lib) {

    // behavior for our module
    function foo() {
        lib.log( "hello world!" );
    }

    // export (expose) foo to other modules as foobar
    return {
        foobar: foo
    }
});

මොඩියුලය වෙනත් තැනක භාවිතා කළ හැකිය:

require(["package/myModule"], function(myModule) {
    myModule.foobar();
});

සමහර පසුබිම:

ඇත්ත වශයෙන්ම, CommonJS යනු API ප්‍රකාශයකට වඩා වැඩි යමක් වන අතර ඒ සමඟ කටයුතු කරන්නේ එහි කොටසක් පමණි. පොදු ජේඑස් ලැයිස්තුවේ මොඩියුල ආකෘතිය සඳහා කෙටුම්පත් පිරිවිතරයක් ලෙස AMD ආරම්භ වූ නමුත් පූර්ණ එකඟතාවකට නොපැමිණි අතර ආකෘතිය තවදුරටත් සංවර්ධනය කිරීම amdjs කාණ්ඩයට ගෙන ගියේය . පොදු ජේඑස් විසින් පුළුල් පරාසයක සැළකිලිමත් වීමට උත්සාහ කරන බවත්, එහි සමමුහුර්ත ස්වභාවය අනුව සේවාදායක පාර්ශවීය සංවර්ධනය සඳහා එය වඩාත් සුදුසු බවත්, ඒඑම්ඩී එහි අසමමුහුර්ත ස්වභාවය සහ සේවාදායක පාර්ශව (බ්‍රව්සර්) සංවර්ධනය සඳහා වඩාත් සුදුසු බවත් තර්ක කරයි. ඩොජෝ හි මොඩියුලය ප්‍රකාශන ක්‍රියාත්මක කිරීමේදී එහි මූලයන් ඇති බව.

මුලාශ්‍ර:

• RequireJS - ඇයි AMD?
• ඇඩී ඔස්මානි - ජාවාස්ක්‍රිප්ට් මෝස්තර රටා ඉගෙනීම - නවීන මොඩියුලර් ජාවාස්ක්‍රිප්ට් මෝස්තර රටා

උපුටා දැක්වීම

AMD :

• එක් බ්‍රව්සරයක පළමු ප්‍රවේශය
• අසමමුහුර්ත හැසිරීම සහ සරල කළ පසුගාමී අනුකූලතාව සඳහා තෝරා ගැනීම
• එයට I / O ගොනුව පිළිබඳ කිසිදු සංකල්පයක් නොමැත.
• එය වස්තූන්, කාර්යයන්, ඉදිකිරීම්කරුවන්, නූල්, JSON සහ තවත් බොහෝ මොඩියුල සඳහා සහය දක්වයි.

CommonJS :

• එක් සේවාදායක පළමු ප්‍රවේශය
• සමමුහුර්ත හැසිරීම උපකල්පනය කිරීම
• I / O, ගොනු පද්ධතිය, පොරොන්දු සහ තවත් බොහෝ පුළුල් කරුණු ආවරණය කරන්න.
• නොකැඩූ මොඩියුල සඳහා සහය දක්වයි, එය ES.next/Harmony පිරිවිතරයන්ට මඳක් සමීප බවක් දැනිය හැකි අතර, බලාත්මක කරන නිර්වචන () එතීමෙන් ඔබව නිදහස් කරයි AMD.
• මොඩියුල ලෙස වස්තූන් සඳහා පමණක් සහාය දක්වන්න.

එය ගොනු කිහිපයක් JavaScript වැඩසටහන රොකට්ටුවක් මොඩියුල සංවිධානය කිරීමට හා කැඳවීමට ඉතා සාමාන්ය දෙයක් child-modulesසිට main js module.

කාරණය වන්නේ ජාවාස්ක්‍රිප්ට් මෙය සපයන්නේ නැත. Chrome සහ FF හි නවතම බ්‍රව්සර් අනුවාදවල අද පවා නොමැත.

නමුත්, වෙනත් ජාවාස්ක්‍රිප්ට් මොඩියුලයක් ඇමතීමට ජාවාස්ක්‍රිප්ට් හි කිසියම් මූල පදයක් තිබේද?

මෙම ප්රශ්නය පිළිතුර නිසා බොහෝ ලෝකයේ මුළු බිඳ වැටීම විය හැකි කිසිදු .

ES5 හි (2009 දී නිකුත් කරන ලදි) ජාවාස්ක්‍රිප්ට් ආනයනය , ඇතුළත් කිරීම හෝ අවශ්‍ය කිරීම වැනි මූල පද නොමැත .

ES6 මෙම යෝජනා (2015 දී නිකුත්) දවස ඉතිරි ආනයන මූල පදය ( https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/import ), නමුත් කිසිදු බ්රවුසරය මෙම ක්රියාත්මක කරයි.

ඔබ බාබෙල් 6.18.0 භාවිතා කරන්නේ නම් සහ ES2015 විකල්පය සමඟ පාරදෘශ්‍ය කරන්න

import myDefault from "my-module";

ඔබට නැවත ලැබෙනු requireඇත.

"use strict";
var _myModule = require("my-module");
var _myModule2 = _interopRequireDefault(_myModule);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

මෙයට හේතුව requireමොඩියුලය Node.js වෙතින් පටවනු ඇති බවයි. පද්ධති මට්ටමේ ලිපිගොනු කියවීමේ සිට මොඩියුලයට එතීමේ කාර්යයන් දක්වා සියල්ල Node.js විසින් හසුරුවනු ඇත.

මොඩියුල නිරූපණය කරන එකම එතීම ජාවාස්ක්‍රිප්ට් වල ඇති නිසාය.

මම CommonJS සහ AMD ගැන ගොඩක් ව්‍යාකූලද?

CommonJS සහ AMD යන දෙකම මොඩියුල ස්මාර්ට් පැටවීම සඳහා ජාවාස්ක්‍රිප්ට් “දෝෂය” මඟහරවා ගත හැකි ක්‍රම දෙකක් පමණි.

AMD

• ජාවාස්ක්‍රිප්ට් ව්‍යාපෘතිය මඟින් ජාවාස්ක්‍රිප්ට් ව්‍යාපෘතිය විවිධ ගොනු වලට පරිමාණය කිරීම සඳහා හඳුන්වා දෙන ලදි
• බ්‍රවුසර පාදක කරගත් යෙදුම් සහ පුස්තකාලවල වැඩිපුරම භාවිතා වේ
• ජනප්‍රිය ක්‍රියාත්මක කිරීම වන්නේ RequireJS , Dojo Toolkit ය

CommonJS :

• විශාල ව්‍යාපෘතියේ කාර්යයන්, ලිපිගොනු සහ මොඩියුල විශාල ප්‍රමාණයක් හැසිරවීම පිරිවිතරයකි
• ආරම්භක නම ServerJS 2009 ජනවාරි මාසයේදී මොසිල්ලා විසින් හඳුන්වා දෙන ලදී
• ඒපීඅයි වල පුළුල් භාවිතාව පෙන්වීම සඳහා 2009 අගෝස්තු මාසයේදී CommonJS ලෙස නම් කරන ලදී
• මුලින් ක්‍රියාත්මක කළේ සේවාදායකය, නෝඩ්ජස්, ඩෙස්ක්ටොප් පදනම් කරගත් පුස්තකාල ය

උදාහරණයක්

top.js ගොනුව

exports.uppercase = str => str.toUpperCase()

main.js ගොනුව

const uppercaseModule = require('uppercase.js')
uppercaseModule.uppercase('test')

සාරාංශය

• AMD - පුස්තකාලය විසින් මුලින් ක්‍රියාත්මක කරන ලද වඩාත්ම පැරණි මොඩියුල පද්ධතියකි.
• CommonJS - Node.js සේවාදායකය සඳහා නිර්මාණය කරන ලද මොඩියුල පද්ධතිය.
• UMD - තවත් එක් මොඩියුල පද්ධතියක්, විශ්වීය එකක් ලෙස යෝජනා කර ඇති අතර එය AMD සහ CommonJSසමඟ අනුකූල වේ.

සම්පත්:

• https://exporingjs.com/es6/ch_modules.html#sec_modules-in-javascript
• විකිපීඩියා