Node.js module.exports හි අරමුණ කුමක්ද සහ ඔබ එය භාවිතා කරන්නේ කෙසේද?

Node.js module.exports හි අරමුණ කුමක්ද සහ ඔබ එය භාවිතා කරන්නේ කෙසේද?

මට මේ පිළිබඳ කිසිදු තොරතුරක් සොයාගත නොහැකි නමුත් එය බොහෝ විට මූලාශ්‍ර කේතයෙන් දකින බැවින් එය Node.js හි තරමක් වැදගත් කොටසක් ලෙස පෙනේ.

අනුව Node.js ප්රලේඛනය :

මොඩියුලය

ධාරාව පිළිබඳ සඳහනක් module. විශේෂයෙන් module.exports අපනයන වස්තුවට සමාන වේ. වැඩි විස්තර src/node.jsසඳහා බලන්න .

නමුත් මෙය සැබවින්ම උදව් නොකරයි.

හරියටම කරන්නේ module.exportsකුමක්ද, සරල උදාහරණයක් වනු ඇත්තේ කුමක් ද?

module.exportsrequireඇමතුමක ප්‍රති result ලයක් ලෙස සැබවින්ම ආපසු ලබා දුන් වස්තුවයි .

මෙම exportsවිචල්ය මුලින්, එම වස්තුව (එය කිමෙක්ද යන්න සාරාංශ "හෙවත්" යි එනම්) සකසා ඇත නිසා මොඩියුලය කේතය ඔබ මේ වගේ සාමාන්යයෙන් කපා දෙයක් බව:

let myFunc1 = function() { ... };
let myFunc2 = function() { ... };
exports.myFunc1 = myFunc1;
exports.myFunc2 = myFunc2;

අභ්‍යන්තරව විෂය පථය අපනයනය කිරීමට (හෝ "නිරාවරණය කිරීමට") myFunc1සහ myFunc2.

ඇමතුම් කේතයේ ඔබ භාවිතා කරන්නේ:

const m = require('./mymodule');
m.myFunc1();

මෙහි අවසාන පේළියේ ප්‍රති result ලය require(සාමාන්‍යයෙන්) ගුණාංගවලට ප්‍රවේශ විය හැකි සරල වස්තුවක් වන්නේ කෙසේද යන්න පෙන්වයි .

සැ.යු: ඔබ නැවත ලියන්නේ exportsනම් එය තවදුරටත් යොමු නොවේ module.exports. එබැවින් ඔබට නව වස්තුවක් (හෝ ශ්‍රිත යොමු කිරීමක්) පැවරීමට අවශ්‍ය නම් ඔබ exportsඑම නව වස්තුවද පැවරිය යුතුයmodule.exports

exportsවස්තුවට එකතු කරන ලද නම, ඔබ එකතු කරන අගය සඳහා මොඩියුලයේ අභ්‍යන්තරව පරික්ෂා කරන ලද නමට සමාන නොවිය යුතු බව සඳහන් කිරීම වටී , එබැවින් ඔබට තිබිය හැකිය:

let myVeryLongInternalName = function() { ... };
exports.shortName = myVeryLongInternalName;
// add other objects, functions, as required

අනුගත:

const m = require('./mymodule');
m.shortName(); // invokes module.myVeryLongInternalName

මේ සඳහා දැනටමත් පිළිතුරු ලබා දී ඇති නමුත් මට පැහැදිලි කිරීමක් එක් කිරීමට අවශ්‍ය විය ...

ඔබ මේ දෙකම භාවිතා කළ හැකි exportsහා module.exportsමේ වගේ ආනයන කේතය ඔබේ අයදුම් පත්:

var mycode = require('./path/to/mycode');

ඔබ දකින මූලික භාවිත අවස්ථාව (උදා: එක්ස්ප්‍රස් ජේඑස් උදාහරණ කේතයෙන්) ඔබ exports.js ගොනුවක ඇති වස්තුව මත ගුණාංග සැකසීම.require()

එබැවින් සරල ගණන් කිරීමේ උදාහරණයකින් ඔබට තිබිය හැක්කේ:

(counter.js):

var count = 1;

exports.increment = function() {
    count++;
};

exports.getCount = function() {
    return count;
};

... ඉන්පසු ඔබගේ යෙදුමේ (web.js, හෝ වෙනත් ඕනෑම .js ගොනුවක්):

var counting = require('./counter.js');

console.log(counting.getCount()); // 1
counting.increment();
console.log(counting.getCount()); // 2

සරළව කිවහොත්, ඔබට අවශ්‍ය ලිපිගොනු තනි වස්තුවක් ආපසු ලබා දෙන කාර්යයන් ලෙස සිතිය හැකි අතර, ඒවා සැකසීමෙන් ආපසු ලබා දුන් වස්තුවට ගුණාංග (නූල්, අංක, අරා, ශ්‍රිත, ඕනෑම දෙයක්) එකතු කළ හැකිය exports.

සමහර විට ඔබට අවශ්‍ය වන්නේ require()ඇමතුමකින් ආපසු එන වස්තුව ගුණාංග සහිත වස්තුවකට වඩා ඔබට ඇමතිය හැකි ශ්‍රිතයක් වීමයි. එවැනි අවස්ථාවකදී ඔබත් මේ ආකාරයට සැකසිය යුතුය module.exports:

(sayhello.js):

module.exports = exports = function() {
    console.log("Hello World!");
};

(app.js):

var sayHello = require('./sayhello.js');
sayHello(); // "Hello World!"

අපනයන සහ මොඩියුලය අතර වෙනස මෙම පිළිතුරෙන් වඩා හොඳින් විස්තර කෙරේ .

මෙම NodeJS මොඩියුලය යාන්ත්රණයක් මත පදනම් වෙලා කටයුතු කරන බව සටහන CommonJS වැනි තවත් බොහෝ නිර්මාණයන් තුළ සහය වන මොඩියුල RequireJS , පමණක් නොව, SproutCore , CouchDB , වෑකන්ද යන , OrientDB , ArangoDB , RingoJS , TeaJS , SilkJS , curl.js , හෝ Adobe Photoshop (හරහා PSLib ). දන්නා ක්‍රියාත්මක කිරීම් පිළිබඳ සම්පූර්ණ ලැයිස්තුව මෙතැනින් ඔබට සොයාගත හැකිය .

ඔබේ මොඩියුලය නෝඩ් විශේෂිත අංග හෝ මොඩියුලය භාවිතා නොකරන්නේ නම්, exportsඒ වෙනුවට module.exports පොදු ජේඑස් ප්‍රමිතියේ කොටසක් නොවන , පසුව බොහෝ විට වෙනත් ක්‍රියාත්මක කිරීම් සඳහා සහාය නොදක්වන ලෙස භාවිතා කිරීමට මම ඔබව උනන්දු කරවන්නෙමි .

තවත් NodeJS විශේෂිත ලක්‍ෂණයක් නම්, exportsමෙම ත්‍රෙඩ් එකේ ජෙඩ් වොට්සන් විසින් සපයන ලද අවසාන උදාහරණයේ දී මෙන් ඔබ නව වස්තුවකට ගුණාංග සහ ක්‍රම එකතු කිරීම වෙනුවට යොමු කිරීමක් ලබා දීමයි . CommonJS මොඩියුල යාන්ත්‍රණයේ චක්‍රලේඛ යොමු සහාය බිඳ දැමීම නිසා මම මෙම ක්‍රියාව පෞද්ගලිකව අධෛර්යමත් කරමි . එවිට සියලු ක්‍රියාත්මක කිරීම් වලට සහාය නොදක්වන අතර වඩාත් විශ්වීය මොඩියුලයක් සැපයීම සඳහා ජෙඩ් උදාහරණය මේ ආකාරයෙන් (හෝ ඒ හා සමාන) ලිවිය යුතුය:

(sayhello.js):

exports.run = function() {
    console.log("Hello World!");
}

(app.js):

var sayHello = require('./sayhello');
sayHello.run(); // "Hello World!"

නැතහොත් ES6 විශේෂාංග භාවිතා කිරීම

(sayhello.js):

Object.assign(exports, {
    // Put all your public API here
    sayhello() {
        console.log("Hello World!");
    }
});

(app.js):

const { sayHello } = require('./sayhello');
sayHello(); // "Hello World!"

PS: ඇප්සලරේටර් විසින් පොදු ජේඑස් මොඩියුලයන් ද ක්‍රියාත්මක කරන බව පෙනේ, නමුත් චක්‍රලේඛ යොමු සහාය නොමැතිව (බලන්න: ඇක්සලරේටර් සහ පොදු ජේඑස් මොඩියුල (හැඹිලි සහ රවුම් යොමු) )

ඔබ නව වස්තුවක් සඳහා exportsසහ / හෝ වෙත යොමු කිරීමක් කරන්නේ නම් ඔබ සැලකිලිමත් විය යුතු කරුණු කිහිපයක් modules.exports:

1. අපනයනය කරන ලද වස්තුව දැන් තවත් නව එකක් සඳහන් කරනු ඇති බැවින් මුලින් මුල් පිටපතට අමුණා ඇති exportsහෝ module.exportsඇත්ත වශයෙන්ම නැති වී ඇත

මෙය පැහැදිලිය, නමුත් පවතින මොඩියුලයක ආරම්භයේ දී ඔබ අපනයනය කළ ක්‍රමයක් එකතු කරන්නේ නම්, දේශීය අපනයනය කරන ලද වස්තුව අවසානයේ වෙනත් වස්තුවක් යොමු නොකිරීමට වග බලා ගන්න

exports.method1 = function () {}; // exposed to the original exported object
exports.method2 = function () {}; // exposed to the original exported object

module.exports.method3 = function () {}; // exposed with method1 & method2

var otherAPI = {
    // some properties and/or methods
}

exports = otherAPI; // replace the original API (works also with module.exports)

2. නව අගයන්ගෙන් එකක් exportsහෝ module.exportsයොමු කිරීමක් නම්, ඔවුන් තවදුරටත් එකම වස්තුව ගැන සඳහන් නොකරයි

exports = function AConstructor() {}; // override the original exported object
exports.method2 = function () {}; // exposed to the new exported object

// method added to the original exports object which not exposed any more
module.exports.method3 = function () {}; 

3. උපක්‍රමශීලී ප්‍රතිවිපාක. ඔබ දෙකටම යොමු කිරීම වෙනස් කරන්නේ නම් exportsසහ module.exportsකුමන API නිරාවරණය වී ඇත්දැයි කීමට අපහසු නම් (එය module.exportsජයග්‍රාහී බව පෙනේ )

// override the original exported object
module.exports = function AConstructor() {};

// try to override the original exported object
// but module.exports will be exposed instead
exports = function AnotherConstructor() {}; 

මොඩියුලය යෙදුම සමඟ බෙදාගත යුතු දේ තෝරා ගැනීමට මොඩියුලයට ඉඩ දෙයි

මොඩියුලය_එපෝර්ට් පිළිබඳ වීඩියෝවක් මා සතුව ඇත

ඔබේ වැඩසටහන් කේතය බහුවිධ ගොනු හරහා බෙදීමේදී, module.exportsමොඩියුලයක පාරිභෝගිකයාට විචල්‍යයන් සහ ක්‍රියාකාරකම් ප්‍රකාශයට පත් කිරීමට භාවිතා කරයි. මෙම require()ඔබේ මූල ගොනුව තුල ඇමතුම් අදාළ සමඟ ආදේශ module.exportsමෙම මොඩියුලය පූර්ණය.

මොඩියුල ලිවීමේදී මතක තබා ගන්න

• මොඩියුල පැටවීම් හැඹිලිගත කර ඇත, ආරම්භක ඇමතුම පමණක් ජාවාස්ක්‍රිප්ට් ඇගයීමට ලක් කරයි.
• මොඩියුලයක් තුළ දේශීය විචල්යයන් සහ කාර්යයන් භාවිතා කළ හැකිය, සියල්ල අපනයනය කිරීම අවශ්ය නොවේ.
• මෙම module.exportsවස්තුව ද ලෙස ලබා ගත හැකි exportsඅයුරෙන්. නමුත් එකම ශ්‍රිතයක් ආපසු ලබා දෙන විට, සෑම විටම භාවිතා කරන්න module.exports.

අනුව: "මොඩියුල 2 කොටස - ලිවීමේ මොඩියුල" .

යොමු සබැඳිය මේ වගේ ය:

exports = module.exports = function(){
    //....
}

ගුණ exportsහෝ module.exports, එවැනි හෝ විචල්ය හෝ කාරක ලෙස, පිටත නිරාවරණය කරනු ඇත

ඔබ වැඩි අවධානයක් යොමු කළ යුතු දෙයක් තිබේ: overrideඅපනයනය නොකරන්න .

ඇයි ?

මන්ද අපනයනය කරනුයේ module.exports හි යොමු කිරීම පමණක් වන අතර, ඔබට දේපල අපනයන වලට එකතු කළ හැකිය, නමුත් ඔබ අපනයන ඉක්මවා ගියහොත්, යොමු සබැඳිය කැඩී යනු ඇත.

හොඳ උදාහරණය:

exports.name = 'william';

exports.getName = function(){
   console.log(this.name);
}

නරක උදාහරණය:

exports = 'william';

exports = function(){
     //...
}

ඔබට එක් ශ්‍රිතයක් හෝ විචල්‍යයක් පමණක් නිරාවරණය කිරීමට අවශ්‍ය නම්, මේ ආකාරයට:

// test.js
var name = 'william';

module.exports = function(){
    console.log(name);
}   

// index.js
var test = require('./test');
test();

මෙම මොඩියුලය නිරාවරණය වී ඇත්තේ එක් ශ්‍රිතයක් පමණක් වන අතර නමේ දේපල පිටතින් පුද්ගලික වේ.

ඔබ http, sys වැනි node.js බාගත කර ස්ථාපනය කරන විට node.js හි පෙරනිමි හෝ පවතින මොඩියුල කිහිපයක් තිබේ .

ඒවා දැනටමත් node.js හි ඇති බැවින්, අපට මෙම මොඩියුල භාවිතා කිරීමට අවශ්‍ය වූ විට අපි මූලික වශයෙන් ආනයන මොඩියුල වලට කැමතියි , නමුත් ඇයි? මන්ද ඒවා දැනටමත් node.js හි ඇති බැවිනි. ආයාත කිරීම හරියට node.js වෙතින් ගෙන ඒවා ඔබේ වැඩසටහනට ඇතුළත් කිරීම වැනිය. ඉන්පසු ඒවා භාවිතා කිරීම.

ඇති ෙහයින්ද අපනයන හරියටම ප්රතිවිරුද්ධ, ඔබට අවශ්ය මොඩියුලය නිර්මාණය කරනු ඇත, ඉඩ ගේ මෙම මොඩියුලය addition.js කියන්න සහ node.js බවට එම මොඩියුලය දමා, ඔබ එය අපනයනය කිරීමෙන් එය කරන්න.

මම මෙතන කිසිම දෙයක් ලියන්න, මතක තියාගන්න, පෙර, module.exports.additionTwo ලෙස සමාන වේ exports.additionTwo

හහ්, ඒ නිසා තමයි අපි කැමති

exports.additionTwo = function(x)
{return x+2;};

මාර්ගය ගැන සැලකිලිමත් වන්න

ඔබ add.js මොඩියුලයක් නිර්මාණය කර ඇති බව කියමු.

exports.additionTwo = function(x){
return x + 2;
};

ඔබ මෙය ඔබගේ NODE.JS විධාන විමසුමේ ක්‍රියාත්මක කරන විට:

node
var run = require('addition.js');

මෙය කීම වැරදිය

දෝෂය: මොඩියුලය එකතු කිරීම සොයාගත නොහැක. Js

මෙයට හේතුව, අපි මාර්ගය සඳහන් නොකිරීම නිසා node.js ක්‍රියාවලියට add.js නොහැකි වීමයි. එබැවින්, අපට NODE_PATH භාවිතා කරමින් මාර්ගය සැකසිය හැකිය

set NODE_PATH = path/to/your/additon.js

දැන්, මෙය කිසිදු දෝෂයක් නොමැතිව සාර්ථකව ක්රියාත්මක විය යුතුය !!

තවත් එක් දෙයක් නම්, ඔබට NODE_PATH සැකසීමෙන් එකතු කිරීම.ජේ ගොනුව ධාවනය කළ හැකිය, ඔබේ nodejs විධාන විමසුමට ආපසු යන්න:

node
var run = require('./addition.js');

වත්මන් නාමාවලියෙහි ඇති බව පවසමින් අපි මෙහි මාර්ගය සපයන බැවින් ./මෙයද සාර්ථකව ක්‍රියාත්මක විය යුතුය.

මොඩියුලයක් අදාළ කේතය තනි කේත ඒකකයකට සම්බන්ධ කරයි. මොඩියුලයක් නිර්මාණය කිරීමේදී, මෙය අදාළ සියලු කාර්යයන් ගොනුවකට ගෙනයාම ලෙස අර්ථ දැක්විය හැකිය.

කාර්යයන් දෙකක් ඇතුළත් Hello.js ගොනුවක් ඇතැයි සිතමු

sayHelloInEnglish = function() {
  return "Hello";
};
sayHelloInSpanish = function() {
  return "Hola";
};

අපි ශ්‍රිතයක් ලියන්නේ කේතයේ උපයෝගීතාව එක් ඇමතුමකට වඩා වැඩි වූ විට පමණි.

වර්ල්ඩ්.ජේස් පවසන පරිදි, ශ්‍රිතයේ උපයෝගීතාව වෙනත් ගොනුවකට වැඩි කිරීමට අපට අවශ්‍ය යැයි සිතමු, මේ අවස්ථාවේ දී ගොනුවක් අපනයනය කිරීම පින්තූරයට පැමිණේ, එය මොඩියුලය.

පහත දැක්වෙන කේතය මඟින් ඔබට ශ්‍රිතය දෙකම අපනයනය කළ හැකිය

var anyVariable={
 sayHelloInEnglish = function() {
      return "Hello";
    };
  sayHelloInSpanish = function() {
      return "Hola";
    }; 
}
module.export=anyVariable;

දැන් ඔබට එම කාර්යයන් භාවිතා කිරීම සඳහා ගොනුවේ නම World.js inorder වෙත අවශ්‍ය වේ

var world= require("./hello.js");

අභිප්රාය වන්නේ:

මොඩියුලර් ක්‍රමලේඛනය යනු මෘදුකාංග සැලසුම් තාක්‍ෂණයකි, එය වැඩසටහනක ක්‍රියාකාරිත්වය ස්වාධීන, හුවමාරු කළ හැකි මොඩියුලවලට වෙන් කිරීම අවධාරණය කරයි, ඒ සෑම එකක්ම අපේක්ෂිත ක්‍රියාකාරීත්වයේ එක් අංගයක් පමණක් ක්‍රියාත්මක කිරීමට අවශ්‍ය සියල්ල අඩංගු වේ.

විකිපීඩියා

මොඩියුලර් / නැවත භාවිතා කළ හැකි කේතයක් නොමැතිව විශාල වැඩසටහන් ලිවීම දුෂ්කර වනු ඇතැයි මම සිතමි. නෝඩ්ජස් වලදී අපට module.exportsනිරාවරණය වන දේ නිර්වචනය කර මොඩියුලර් වැඩසටහන් නිර්මාණය කළ හැකිය require.

මෙම උදාහරණය උත්සාහ කරන්න:

fileLog.js

function log(string) { require('fs').appendFileSync('log.txt',string); }

module.exports = log;

stdoutLog.js

function log(string) { console.log(string); }

module.exports = log;

program.js

const log = require('./stdoutLog.js')

log('hello world!');

ක්‍රියාත්මක කරන්න

ode node program.js

හෙලෝ වර්ල්ඩ්!

දැන් ./fileLog.js සඳහා ./stdoutLog.js මාරු කිරීමට උත්සාහ කරන්න .

මොඩියුල පද්ධතියක අරමුණ කුමක්ද?

එය පහත සඳහන් දෑ ඉටු කරයි:

1. අපගේ ලිපිගොනු පුපුරා යාමේ සිට විශාල ප්‍රමාණ දක්වා තබා ගනී. උදා: කේත පේළි 5000 ක් සහිත ලිපිගොනු තිබීම සාමාන්‍යයෙන් සංවර්ධනයේදී කටයුතු කිරීමට අපහසුය.
2. උත්සුකයන් වෙන් කිරීම බලාත්මක කරයි. අපගේ කේතය බහුවිධ ගොනු වලට බෙදීමෙන් සෑම ගොනුවකටම සුදුසු ගොනු නම් තිබිය හැක. මේ ආකාරයෙන් සෑම මොඩියුලයක්ම කරන්නේ කුමක්ද සහ එය සොයාගත හැක්කේ කොතැනින්ද යන්න අපට පහසුවෙන් හඳුනාගත හැකිය (අපි තාර්කික නාමාවලි ව්‍යුහයක් සෑදුවෙමු යැයි සිතමු. එය තවමත් ඔබේ වගකීම වේ).

මොඩියුල තිබීම අපගේ කේත වඩාත් නඩත්තු කළ හැකි කේතයේ සමහර කොටස් සොයා ගැනීම පහසු කරයි.

එය ක්‍රියාත්මක වන්නේ කෙසේද?

NodejS පහත දැක්වෙන ආකාරයට ක්‍රියාත්මක වන CommomJS මොඩියුල පද්ධතිය භාවිතා කරයි:

1. ගොනුවකට යමක් අපනයනය කිරීමට අවශ්‍ය නම් එය module.exportසින්ටැක්ස් භාවිතයෙන් ප්‍රකාශ කළ යුතුය
2. ගොනුවකට යමක් ආනයනය කිරීමට අවශ්‍ය නම් එය require('file')සින්ටැක්ස් භාවිතයෙන් ප්‍රකාශ කළ යුතුය

උදාහරණයක්:

test1.js

const test2 = require('./test2');    // returns the module.exports object of a file

test2.Func1(); // logs func1
test2.Func2(); // logs func2

test2.js

module.exports.Func1 = () => {console.log('func1')};

exports.Func2 = () => {console.log('func2')};

දැනගත යුතු වෙනත් ප්‍රයෝජනවත් දේවල්:

1. මොඩියුලයන් හැඹිලිගත වෙමින් පවතී . ඔබ එකම මොඩියුලය විවිධ ගොනු 2 කින් පූරණය කරන විට මොඩියුලය එක් වරක් පමණක් පැටවිය යුතුය. දෙවන වරට require()එකම මොඩියුලයක් මත කැඳවූ විට එය හැඹිලියෙන් ඇද ගනු ලැබේ.
2. මොඩියුල සමමුහුර්තව පටවනු ලැබේ . මෙම හැසිරීම අවශ්‍ය වේ, එය අසමමුහුර්ත නම් අපට එකවරම ලබාගත් වස්තුවට ප්‍රවේශ විය නොහැක require().

let test = function() {
    return "Hello world"
};
exports.test = test;