Node.js හි, මගේ අනෙක් ලිපිගොනු වල කාර්යයන් “ඇතුළත් කරන්නේ” කෙසේද?

මට app.js නමින් ගොනුවක් ඇති බව කියමු. ඉතා සරලයි:

var express = require('express');
var app = express.createServer();
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.get('/', function(req, res){
  res.render('index', {locals: {
    title: 'NowJS + Express Example'
  }});
});

app.listen(8080);

මට "tools.js" තුළ ශ්‍රිතයක් තිබේ නම් කුමක් කළ යුතුද? Apps.js හි භාවිතා කිරීමට මම ඒවා ආනයනය කරන්නේ කෙසේද?

නැත්නම් ... මම "මෙවලම්" මොඩියුලයක් බවට පත් කළ යුතු අතර පසුව එය අවශ්‍යද? << අමාරු බව පෙනේ, මම කරන්නේ tools.js ගොනුවේ මූලික ආනයනයයි.

ඔබට ඕනෑම js ගොනුවක් අවශ්‍ය විය හැකිය, ඔබට නිරාවරණය කිරීමට අවශ්‍ය දේ ප්‍රකාශ කළ යුතුය.

// tools.js
// ========
module.exports = {
  foo: function () {
    // whatever
  },
  bar: function () {
    // whatever
  }
};

var zemba = function () {
}

ඔබගේ යෙදුම් ගොනුවේ:

// app.js
// ======
var tools = require('./tools');
console.log(typeof tools.foo); // => 'function'
console.log(typeof tools.bar); // => 'function'
console.log(typeof tools.zemba); // => undefined

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

var fs = require('fs');

// file is included here:
eval(fs.readFileSync('tools.js')+'');

• +''ලිපිගොනු අන්තර්ගතය නූලක් ලෙස ලබා ගැනීම සඳහා හිස් නූල් සම්මුතියක් අවශ්‍ය වන අතර එය වස්තුවක් නොවේ (ඔබට අවශ්‍ය .toString()නම් භාවිතා කළ හැකිය ).
• ශ්‍රිතය තුළ eval () භාවිතා කළ නොහැක එය ගෝලීය විෂය පථය තුළට කැඳවිය යුතුය . එසේ නොමැතිනම් කිසිදු ශ්‍රිතයක් හෝ විචල්‍යයක් වෙත ප්‍රවේශ විය නොහැක (එනම් ඔබට include()උපයෝගිතා ශ්‍රිතයක් හෝ එවැනි දෙයක් නිර්මාණය කළ නොහැක ).

බොහෝ අවස්ථාවල මෙය බව කරුණාවෙන් සලකන්න නරක පුරුද්දක් වන අතර ඒ වෙනුවට ඔබ මොඩියුලයක් ලිවිය යුතු . කෙසේ වෙතත්, දුර්ලභ අවස්ථාවන් තිබේ, ඔබේ දේශීය සන්දර්භය / නාම අවකාශය දූෂණය වීම ඔබට සැබවින්ම අවශ්‍ය වේ.

යාවත්කාලීන කිරීම 2015-08-06

"ආනයනය කරන ලද" ගොනුවේ අර්ථ දක්වා ඇති කාර්යයන් සහ විචල්‍යයන් ආනයනය කරන කේතයට ප්‍රවේශ විය නොහැකි නිසා මෙය"use strict"; (ඔබ "දැඩි ප්‍රකාරයේ" සිටින විට ) ක්‍රියා නොකරනු ඇති බව කරුණාවෙන් සලකන්න . දැඩි මාදිලිය භාෂා ප්‍රමිතියේ නවතම අනුවාදයන් මගින් අර්ථ දක්වා ඇති සමහර නීති ක්‍රියාත්මක කරයි. මෙහි විස්තර කර ඇති විසඳුම වළක්වා ගැනීමට මෙය තවත් හේතුවක් විය හැකිය .

ඔබට නව කාර්යයන් හෝ නව මොඩියුල අවශ්‍ය නොවේ. ඔබට නාම අවකාශය භාවිතා කිරීමට අවශ්‍ය නැතිනම් ඔබ අමතන මොඩියුලය ක්‍රියාත්මක කිරීමට අවශ්‍යය.

tools.js හි

module.exports = function() { 
    this.sum = function(a,b) { return a+b };
    this.multiply = function(a,b) { return a*b };
    //etc
}

app.js හි

හෝ වෙනත් ඕනෑම .js වැනි myController.js:

වෙනුවට

var tools = require('tools.js') එමඟින් නාම අවකාශයක් සහ ඇමතුම් මෙවලම් භාවිතා කිරීමට අපට බල කරයි tools.sum(1,2);

අපට සරලව ඇමතිය හැකිය

require('tools.js')();

ඊළගට

sum(1,2);

මගේ නඩුවේ මට පාලකයන් සමඟ ගොනුවක් ඇත ctrls.js

module.exports = function() {
    this.Categories = require('categories.js');
}

Categoriesසෑම සන්දර්භයකින්ම මට පසුව පොදු පංතියක් ලෙස භාවිතා කළ හැකියrequire('ctrls.js')()

Js ගොනු දෙකක් සාදන්න

// File cal.js
module.exports = {
    sum: function(a,b) {
        return a+b
    },
    multiply: function(a,b) {
        return a*b
    }
};

ප්‍රධාන js ගොනුව

// File app.js
var tools = require("./cal.js");
var value = tools.sum(10,20);
console.log("Value: "+value);

කොන්සෝල ප්‍රතිදානය

Value: 30

මෙන්න සරල හා සරල පැහැදිලි කිරීමක්:

Server.js අන්තර්ගතය:

// Include the public functions from 'helpers.js'
var helpers = require('./helpers');

// Let's assume this is the data which comes from the database or somewhere else
var databaseName = 'Walter';
var databaseSurname = 'Heisenberg';

// Use the function from 'helpers.js' in the main file, which is server.js
var fullname = helpers.concatenateNames(databaseName, databaseSurname);

Helpers.js අන්තර්ගතය:

// 'module.exports' is a node.JS specific feature, it does not work with regular JavaScript
module.exports = 
{
  // This is the function which will be called in the main file, which is server.js
  // The parameters 'name' and 'surname' will be provided inside the function
  // when the function is called in the main file.
  // Example: concatenameNames('John,'Doe');
  concatenateNames: function (name, surname) 
  {
     var wholeName = name + " " + surname;

     return wholeName;
  },

  sampleFunctionTwo: function () 
  {

  }
};

// Private variables and functions which will not be accessible outside this file
var privateFunction = function () 
{
};

උදා: ගොනු දෙකක් නිර්මාණය app.jsහාtools.js

app.js

const tools= require("./tools.js")


var x = tools.add(4,2) ;

var y = tools.subtract(4,2);


console.log(x);
console.log(y);

tools.js

 const add = function(x, y){
        return x+y;
    }
 const subtract = function(x, y){
            return x-y;
    }

    module.exports ={
        add,subtract
    }

ප්‍රතිදානය

6
2

මම NodeJS හි 'ඇතුළත්' ශ්‍රිතයක් ද සොයමින් සිටි අතර මම උදෝ ජී විසින් යෝජනා කරන ලද විසඳුම පරීක්ෂා කර බැලුවෙමි - පණිවිඩය https://stackoverflow.com/a/8744519/2979590 බලන්න . ඔහුගේ කේතය මා ඇතුළත් කළ JS ගොනු සමඟ ක්‍රියා නොකරයි. අවසාන වශයෙන් මම ඒ වගේ ගැටලුව විසඳුවා:

var fs = require("fs");

function read(f) {
  return fs.readFileSync(f).toString();
}
function include(f) {
  eval.apply(global, [read(f)]);
}

include('somefile_with_some_declarations.js');

නිසැකවම, එය උපකාරී වේ.

අපි උත්සවය ඇමතීමට අවශ්ය කියන්න පිං () හා එක් (30,20) තුළ ඇති lib.js ගොනුව main.js

main.js

lib = require("./lib.js")

output = lib.ping();
console.log(output);

//Passing Parameters
console.log("Sum of A and B = " + lib.add(20,30))

lib.js

this.ping=function ()
{
    return  "Ping Success"
}

//Functions with parameters
this.add=function(a,b)
    {
        return a+b
    }

Node.js හි ඇති vm මොඩියුලය වත්මන් සන්දර්භය තුළ (ගෝලීය වස්තුව ඇතුළුව) ජාවාස්ක්‍රිප්ට් කේතය ක්‍රියාත්මක කිරීමේ හැකියාව සපයයි. Http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filename බලන්න

අද වන විට, vm මොඩියුලයේ දෝෂයක් ඇති අතර එය නව සන්දර්භයකින් ආයාචනා කරන විට නිවැරදිව ක්‍රියා කිරීමෙන් runInThisContext වළක්වයි. මෙය වැදගත් වන්නේ ඔබේ ප්‍රධාන වැඩසටහන නව සන්දර්භයක් තුළ කේතය ක්‍රියාත්මක කර එම කේතය runInThisContext අමතන්නේ නම් පමණි. Https://github.com/joyent/node/issues/898 බලන්න

කනගාටුවට කරුණක් නම්, ප්‍රනාන්දු විසින් යෝජනා කරන ලද (ගෝලීය) ප්‍රවේශය “ශ්‍රිත foo () {}” වැනි නම් කරන ලද කාර්යයන් සඳහා ක්‍රියා නොකරයි.

කෙටියෙන් කිවහොත්, මෙහි මා සඳහා වැඩ කරන () ශ්‍රිතයක් ඇත:

function include(path) {
    var code = fs.readFileSync(path, 'utf-8');
    vm.runInThisContext(code, path);
}

උදෝ ජී පැවසුවේ:

• එවාල් () ශ්‍රිතයක් තුළ භාවිතා කළ නොහැකි අතර එය ගෝලීය විෂය පථය තුළට කැඳවිය යුතුය. එසේ නොමැතිනම් කිසිදු ශ්‍රිතයක් හෝ විචල්‍යයක් වෙත ප්‍රවේශ විය නොහැක (එනම් ඔබට ඇතුළත් කිරීමේ () උපයෝගිතා ශ්‍රිතයක් හෝ එවැනි දෙයක් නිර්මාණය කළ නොහැක).

ඔහු හරි, නමුත් ශ්‍රිතයකින් ගෝලීය විෂය පථයට බලපෑම් කිරීමට ක්‍රමයක් තිබේ. ඔහුගේ ආදර්ශය වැඩි දියුණු කිරීම:

function include(file_) {
    with (global) {
        eval(fs.readFileSync(file_) + '');
    };
};

include('somefile_with_some_declarations.js');

// the declarations are now accessible here.

බලාපොරොත්තුව, එය උපකාරී වේ.

එය පහත සඳහන් පරිදි මා සමඟ වැඩ කළේය ....

Lib1.js

//Any other private code here 

// Code you want to export
exports.function1 = function(params) {.......};
exports.function2 = function(params) {.......};

// Again any private code

දැන් Main.js ගොනුවේ ඔබ Lib1.js ඇතුළත් කළ යුතුය

var mylib = requires('lib1.js');
mylib.function1(params);
mylib.function2(params);

කරුණාකර මතක තබා ගන්න Lib1.js node_modules ෆෝල්ඩරයට දැමීමට .

ඔබට ඔබගේ කාර්යයන් ගෝලීය විචල්‍යයන් තුළ තැබිය හැකිය, නමුත් ඔබේ මෙවලම් පිටපත මොඩියුලයක් බවට පත් කිරීම වඩා හොඳ පුරුද්දකි. එය ඇත්තෙන්ම එතරම් අපහසු නැත - ඔබේ පොදු API exportsවස්තුවට අමුණන්න . වැඩි විස්තර සඳහා අවබෝධය Node.js හි අපනයන මොඩියුලය දෙස බලන්න .

මගේ මතය අනුව මෙය කළ හැකි තවත් ක්‍රමයක් නම්, ඔබ අවශ්‍ය විට () ශ්‍රිතය භාවිතා කරමින් (ශ්‍රිතය (/ * මෙහි දේවල් * /) {}) () (); මෙය කිරීමෙන් එවාල් () විසඳුම මෙන් මෙම සියලු කාර්යයන් ගෝලීය විෂය පථයක් බවට පත් කරනු ඇත

src / lib.js

(function () {
    funcOne = function() {
            console.log('mlt funcOne here');
    }

    funcThree = function(firstName) {
            console.log(firstName, 'calls funcThree here');
    }

    name = "Mulatinho";
    myobject = {
            title: 'Node.JS is cool',
            funcFour: function() {
                    return console.log('internal funcFour() called here');
            }
    }
})();

ඉන්පසු ඔබේ ප්‍රධාන කේතය තුළ ඔබේ කාර්යයන් පහත පරිදි අමතන්න:

main.js

require('./src/lib')
funcOne();
funcThree('Alex');
console.log(name);
console.log(myobject);
console.log(myobject.funcFour());

මෙම ප්‍රතිදානය කරයි

bash-3.2$ node -v
v7.2.1
bash-3.2$ node main.js 
mlt funcOne here
Alex calls funcThree here
Mulatinho
{ title: 'Node.JS is cool', funcFour: [Function: funcFour] }
internal funcFour() called here
undefined

ඔබ මගේ object.funcFour () අමතන විට නිර්වචනය නොකළ දේට අවධානය යොමු කරන්න , ඔබ eval () සමඟ පටවන්නේ නම් එය සමාන වේ. එය උපකාරී වේ යැයි සිතමි :)

ඔබේ මෙවලම්.ජේ වෙතින් ආනයනය කරන ලද යම් යම් කාර්යයන් ඔබට අවශ්‍ය නම්, එක් කිරීමට මට අවශ්‍යය , එවිට ඔබට 6.4 අනුවාදයේ සිට node.js හි සහය දක්වන විනාශකාරී පැවරුමක් භාවිතා කළ හැකිය - node.green බලන්න .

උදාහරණය : (ගොනු දෙකම එකම ෆෝල්ඩරයේ ඇත)

tools.js

module.exports = {
    sum: function(a,b) {
        return a + b;
    },
    isEven: function(a) {
        return a % 2 == 0;
    }
};

main.js

const { isEven } = require('./tools.js');

console.log(isEven(10));

ප්‍රතිදානය: true

පහත දැක්වෙන (පොදු) පැවරුමේදී ඔබ එම කාර්යයන් වෙනත් වස්තුවක ගුණාංග ලෙස පැවරීම ද වළක්වයි:

const tools = require('./tools.js');

ඔබට ඇමතිය යුතු තැන tools.isEven(10).

සටහන:

ඔබගේ ගොනුවේ නම නිවැරදි මාර්ගයෙන් උපසර්ග කිරීමට අමතක නොකරන්න - ගොනු දෙකම එකම ෆෝල්ඩරයේ තිබුණත්, ඔබ සමඟ උපසර්ගය අවශ්‍ය වේ ./

සිට Node.js ලේඛන :

ගොනුවක් දැක්වීමට ප්‍රමුඛ '/', './' හෝ '../' නොමැතිව මොඩියුලය මූලික මොඩියුලයක් විය යුතුය, නැතහොත් node_modules ෆෝල්ඩරයකින් පටවනු ලැබේ.

app.js

let { func_name } = require('path_to_tools.js');
func_name();    //function calling

tools.js

let func_name = function() {
    ...
    //function body
    ...
};

module.exports = { func_name };

ගොනුව ඇතුළත් කර එය ලබා දී ඇති (ගෝලීය නොවන) සන්දර්භය තුළ ක්‍රියාත්මක කරන්න

fileToInclude.js

define({
    "data": "XYZ"
});

main.js

var fs = require("fs");
var vm = require("vm");

function include(path, context) {
    var code = fs.readFileSync(path, 'utf-8');
    vm.runInContext(code, vm.createContext(context));
}


// Include file

var customContext = {
    "define": function (data) {
        console.log(data);
    }
};
include('./fileToInclude.js', customContext);

මම මෙතෙක් නිර්මාණය කර ඇති හොඳම ක්‍රමය මෙයයි.

var fs = require('fs'),
    includedFiles_ = {};

global.include = function (fileName) {
  var sys = require('sys');
  sys.puts('Loading file: ' + fileName);
  var ev = require(fileName);
  for (var prop in ev) {
    global[prop] = ev[prop];
  }
  includedFiles_[fileName] = true;
};

global.includeOnce = function (fileName) {
  if (!includedFiles_[fileName]) {
    include(fileName);
  }
};

global.includeFolderOnce = function (folder) {
  var file, fileName,
      sys = require('sys'),
      files = fs.readdirSync(folder);

  var getFileName = function(str) {
        var splited = str.split('.');
        splited.pop();
        return splited.join('.');
      },
      getExtension = function(str) {
        var splited = str.split('.');
        return splited[splited.length - 1];
      };

  for (var i = 0; i < files.length; i++) {
    file = files[i];
    if (getExtension(file) === 'js') {
      fileName = getFileName(file);
      try {
        includeOnce(folder + '/' + file);
      } catch (err) {
        // if (ext.vars) {
        //   console.log(ext.vars.dump(err));
        // } else {
        sys.puts(err);
        // }
      }
    }
  }
};

includeFolderOnce('./extensions');
includeOnce('./bin/Lara.js');

var lara = new Lara();

අපනයනය කිරීමට අවශ්‍ය දේ ඔබ තවමත් දැනුම් දිය යුතුය

includeOnce('./bin/WebServer.js');

function Lara() {
  this.webServer = new WebServer();
  this.webServer.start();
}

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

මොඩියුල ලිවීමකින් තොරව කේත ඇතුළත් කිරීමට විකල්පයක් මම සොයමින් සිටියෙමි. Node.js සේවාවක් සඳහා වෙනත් ව්‍යාපෘතියකින් එකම අත්හදා බැලූ ස්වාධීන ප්‍රභවයන් භාවිතා කරන්න - සහ jmparatte ගේ පිළිතුර එය මා වෙනුවෙන් කළේය.

වාසිය නම්, ඔබ නාම අවකාශය දූෂණය නොකරන්න, මට කරදරයක් නැත "use strict"; අතර එය හොඳින් ක්‍රියාත්මක වේ.

මෙන්න සම්පූර්ණයි නියැදිය:

පූරණය කිරීමට ස්ක්‍රිප්ට් - /lib/foo.js

"use strict";

(function(){

    var Foo = function(e){
        this.foo = e;
    }

    Foo.prototype.x = 1;

    return Foo;

}())

SampleModule - index.js

"use strict";

const fs = require('fs');
const path = require('path');

var SampleModule = module.exports = {

    instAFoo: function(){
        var Foo = eval.apply(
            this, [fs.readFileSync(path.join(__dirname, '/lib/foo.js')).toString()]
        );
        var instance = new Foo('bar');
        console.log(instance.foo); // 'bar'
        console.log(instance.x); // '1'
    }

}

කෙසේ හෝ මෙය ප්‍රයෝජනවත් වේ යැයි සිතමි.

ඔබට ගොනුවක් තිබෙන්නාක් මෙන් abc.txt අතර තවත් බොහෝ දේ තිබේද?

: 2 ගොනු නිර්මාණය fileread.jsහා fetchingfile.jsඑවකට, fileread.jsලිවීම් මෙම කේතය:

function fileread(filename) {
    var contents= fs.readFileSync(filename);
        return contents;
    }

    var fs = require("fs");  // file system

    //var data = fileread("abc.txt");
    module.exports.fileread = fileread;
    //data.say();
    //console.log(data.toString());
}

දී fetchingfile.jsකපා මෙම කේතය:

function myerror(){
    console.log("Hey need some help");
    console.log("type file=abc.txt");
}

var ags = require("minimist")(process.argv.slice(2), { string: "file" });
if(ags.help || !ags.file) {
    myerror();
    process.exit(1);
}
var hello = require("./fileread.js");
var data = hello.fileread(ags.file);  // importing module here 
console.log(data.toString());

දැන්, ටර්මිනලයක: $ node fetchingfile.js --file = abc.txt

ඔබ ගොනුවේ නම තර්කයක් ලෙස සම්මත කරයි, එපමණක් නොව, සියලු ලිපිගොනු readfile.jsසම්මත කිරීම වෙනුවට ඇතුළත් කරන්න .

ස්තූතියි

Node.js සහ express.js රාමුව භාවිතා කරන විට තවත් ක්‍රමයක්

var f1 = function(){
   console.log("f1");
}
var f2 = function(){
   console.log("f2");
}

module.exports = {
   f1 : f1,
   f2 : f2
}

මෙය s නම් වූ js ගොනුවක සහ ෆෝල්ඩරයේ සංඛ්‍යාන තුළ ගබඩා කරන්න

දැන් ශ්‍රිතය භාවිතා කිරීමට

var s = require('../statics/s');
s.f1();
s.f2();

ඔබට සරල කළ හැකිය require('./filename').

උදා.

// file: index.js
var express = require('express');
var app = express();
var child = require('./child');
app.use('/child', child);
app.get('/', function (req, res) {
  res.send('parent');
});
app.listen(process.env.PORT, function () {
  console.log('Example app listening on port '+process.env.PORT+'!');
});

// file: child.js
var express = require('express'),
child = express.Router();
console.log('child');
child.get('/child', function(req, res){
  res.send('Child2');
});
child.get('/', function(req, res){
  res.send('Child');
});

module.exports = child;

කරුණාකර එය සටහන් කරන්න:

1. ඔබට ළමා ගොනුවේ PORT සවන් දිය නොහැක, PORT සවන්දෙන්නන් සිටින්නේ මව් අධිවේගී මොඩියුලයට පමණි
2. දරුවා භාවිතා කරන්නේ 'රවුටරය' මිස මව් එක්ස්ප්‍රස් මූඩ්ල් නොවේ.

HTML සැකිලි සඳහා මෙය හැසිරවීමේ තරමක් ගොරහැඩි ක්‍රමයක් මා ඉදිරිපත් කර ඇත. එසේම PHP වලට<?php include("navigation.html"); ?>

server.js

var fs = require('fs');

String.prototype.filter = function(search,replace){
    var regex = new RegExp("{{" + search.toUpperCase() + "}}","ig");
    return this.replace(regex,replace);
}

var navigation = fs.readFileSync(__dirname + "/parts/navigation.html");

function preProcessPage(html){
    return html.filter("nav",navigation);
}

var express = require('express');
var app = express();
// Keep your server directory safe.
app.use(express.static(__dirname + '/public/'));
// Sorta a server-side .htaccess call I suppose.
app.get("/page_name/",function(req,res){
    var html = fs.readFileSync(__dirname + "/pages/page_name.html");
    res.send(preProcessPage(html));
});

page_name.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <title>NodeJS Templated Page</title>
    <link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
    <link rel="stylesheet" type="text/css" href="/css/font-awesome.min.css">
    <!-- Scripts Load After Page -->
    <script type="text/javascript" src="/js/jquery.min.js"></script>
    <script type="text/javascript" src="/js/tether.min.js"></script>
    <script type="text/javascript" src="/js/bootstrap.min.js"></script>
</head>
<body>
    {{NAV}}
    <!-- Page Specific Content Below Here-->
</body>
</html>

navigation.html

<nav></nav>

පටවන ලද ප්‍රති ult ලය

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <title>NodeJS Templated Page</title>
    <link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
    <link rel="stylesheet" type="text/css" href="/css/font-awesome.min.css">
    <!-- Scripts Load After Page -->
    <script type="text/javascript" src="/js/jquery.min.js"></script>
    <script type="text/javascript" src="/js/tether.min.js"></script>
    <script type="text/javascript" src="/js/bootstrap.min.js"></script>
</head>
<body>
    <nav></nav>
    <!-- Page Specific Content Below Here-->
</body>
</html>

දේවල් වේගවත් කිරීම සඳහා, ඔබ බහු CPU සහ මයික්‍රෝ සර්විසස් ගෘහ නිර්මාණ ශිල්පයෙන් ප්‍රයෝජන ගැනීමට කැමති නම් ... දෙබලක ක්‍රියාදාමයන් හරහා RPC භාවිතා කරන්න.

සංකීර්ණ බවක් පෙනේ, නමුත් ඔබ බූවල්ලා භාවිතා කරන්නේ නම් එය සරල ය පෙනේ .

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

tools.js මත එකතු කරන්න:

const octopus = require('octopus');
var rpc = new octopus('tools:tool1');

rpc.over(process, 'processRemote');

var sum = rpc.command('sum'); // This is the example tool.js function to make available in app.js

sum.provide(function (data) { // This is the function body
    return data.a + data.b;
});

app.js හි, එකතු කරන්න:

const { fork } = require('child_process');
const octopus = require('octopus');
const toolprocess = fork('tools.js');

var rpc = new octopus('parent:parent1');
rpc.over(toolprocess, 'processRemote');

var sum = rpc.command('sum');

// Calling the tool.js sum function from app.js
sum.call('tools:*', {
    a:2, 
    b:3
})
.then((res)=>console.log('response : ',rpc.parseResponses(res)[0].response));

හෙළිදරව් කිරීම - මම බූවල්ලාගේ කතුවරයා වන අතර සැහැල්ලු පුස්තකාල කිසිවක් සොයාගත නොහැකි වූ නිසා මගේ සමාන භාවිතයක් සඳහා එය ඉදිකර තිබේ.

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

//util.js
module.exports = {
   myFunction: function () {
   // your logic in here
   let message = "I am message from myFunction";
   return message; 
  }
}

දැන් අපට මෙම අපනයන ගෝලීය විෂය පථයට පැවරිය යුතුය (ඔබගේ යෙදුමේ | දර්ශකය | server.js)

var util = require('./util');

දැන් ඔබට ශ්‍රිතය යොමු කර ඇමතිය හැකිය:

//util.myFunction();
console.log(util.myFunction()); // prints in console :I am message from myFunction 

භාවිත:

var mymodule = require("./tools.js")

app.js:

module.exports.<your function> = function () {
    <what should the function do>
}

හායි, මම විශ්වාස කරන්නේ ඔබ මුලින්ම යෙදුම් ගොනුවෙන් අපනයනය කළ යුතු අතර පසුව මෙවලම tool.js හි අවශ්‍ය වේ.

http://www.techprofgyan.com/2020/06/post-1.html