Jak w „Node.js” mogę „włączyć” funkcje z moich innych plików?


967

Załóżmy, że mam plik o nazwie app.js. Dość proste:

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);

Co jeśli mam funkcje wewnątrz „tools.js”. Jak mam je zaimportować do użycia w apps.js?

A może… czy mam zamienić „narzędzia” w moduł, a następnie go potrzebować? << wydaje się trudne, raczej wykonuję podstawowy import pliku tools.js.


4
To, co mnie tu wyrzuciło, to requireumieszczenie folderu w tym samym katalogu w systemie Windows. Musisz użyć adresowania w stylu uniksowym: ./mydirzamiast zwykłego starego mydir.
Ben

1
Utworzyłem moduł do importowania skryptów, eksportowania do pliku i dołączania modułu z node_modulesfolderu zewnętrznego . npmjs.com/package/node-import Mam nadzieję, że może pomóc. Dzięki!
Nanang Mahdaen El-Agung

Odpowiedzi:


1414

Możesz wymagać dowolnego pliku js, wystarczy zadeklarować, co chcesz udostępnić.

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

var zemba = function () {
}

A w pliku aplikacji:

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

101
+1 Ładnie wykonane, ogranicza nawet importowany kod do własnej przestrzeni nazw. Muszę to zanotować na później.
Evan Plaice,

8
Zastanawiam się, czy można zaimportować zewnętrzne skrypty. require("http://javascript-modules.googlecode.com/svn/functionChecker.js")nie wydaje się poprawnie importować modułu. Czy istnieje jakiś inny sposób importowania zewnętrznych skryptów?
Anderson Green

6
A co jeśli będę musiał przekazać zmienną do funkcji Like, bar: function (a, b) {// jakiś kod}
Nishutosh Sharma

5
Ponieważ udostępniasz właściwości, użyłbym eksportu zamiast modułu module.eksporty. W przypadku eksportu kontra moduł. Eksport: stackoverflow.com/questions/5311334/…
Farma

4
jak wywołać funkcję bar (), wewnątrz funkcji foo (), oznacza jak uzyskać dostęp do jednej funkcji za pomocą drugiej
pitu

303

Jeśli pomimo wszystkich innych odpowiedzi nadal chcesz tradycyjnie dołączyć plik do pliku źródłowego node.js, możesz użyć tego:

var fs = require('fs');

// file is included here:
eval(fs.readFileSync('tools.js')+'');
  • Łączenie pustych ciągów +''jest konieczne, aby uzyskać zawartość pliku jako ciąg, a nie obiekt (możesz także użyć.toString() jeśli wolisz).
  • Funkcja eval () nie może być używana wewnątrz funkcji i musi być wywoływana w zakresie globalnym, w przeciwnym razie żadne funkcje lub zmienne nie będą dostępne (tj. Nie będzie można utworzyć include()funkcji narzędzia lub czegoś takiego).

Pamiętaj, że w większości przypadków jest to zła praktyka i powinieneś zamiast tego napisać moduł . Jednak zdarzają się rzadkie sytuacje, w których zanieczyszczenie lokalnego kontekstu / przestrzeni nazw jest tym, czego naprawdę chcesz.

Aktualizacja 2015-08-06

Pamiętaj też, że to nie zadziała "use strict";(gdy jesteś w „trybie ścisłym” ), ponieważ funkcje i zmienne zdefiniowane w „importowanym” pliku nie są dostępne przez kod, który dokonuje importu. Tryb ścisły wymusza niektóre reguły określone przez nowsze wersje standardu językowego. Może to być kolejny powód do uniknięcia opisanego tutaj rozwiązania.


41
Fajnie, jest to przydatne do szybkiego umieszczania bibliotek JS zaprojektowanych dla klienta w aplikacji node.js bez konieczności utrzymywania rozwidlenia w stylu Node.
Kos

18
Właśnie odpowiedziałem na oryginalne pytanie, które dotyczy włączenia kodu, a nie pisania modułów. Ten pierwszy może mieć zalety w niektórych sytuacjach. Również twoje założenie o wymaganiu jest błędne: kod jest z pewnością ewaluowany, ale pozostaje w swojej własnej przestrzeni nazw i nie ma możliwości „zanieczyszczenia” przestrzeni nazw kontekstu wywołującego, dlatego musisz ją ewaluować () samodzielnie. W większości przypadków stosowanie metody opisanej w mojej odpowiedzi jest złą praktyką, ale to nie ja powinienem decydować, czy to dla TIMEX.
Udo G

14
@EvanPlaice: czy masz lepszą sugestię, która faktycznie odpowiada na pytanie ? Jeśli potrzebujesz dołączyć plik, który nie jest modułem , czy masz lepsze podejście niż to?
lipiec

8
Czasami potrzebujesz, a czasem potrzebujesz, są to dwie zasadniczo różne koncepcje w większości języków programowania, również Node JS. Szczerze mówiąc, możliwość włączenia js powinna być częścią Node, ale ewaluacja jest w gruncie rzeczy przyzwoitym rozwiązaniem. Pozytywne.
J. Martin

4
Zauważ, że jest to niezgodne z use strict - ponieważ use strict ograniczy użycie eval, blokując wprowadzanie nowych zmiennych poprzez eval itp.
timbo

189

Nie potrzebujesz żadnych nowych funkcji ani nowych modułów. Musisz po prostu uruchomić moduł, do którego dzwonisz, jeśli nie chcesz używać przestrzeni nazw.

w tools.js

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

w app.js

lub w dowolnym innym .js, takim jak myController.js:

zamiast

var tools = require('tools.js') które zmuszają nas do korzystania z przestrzeni nazw i wywoływania narzędzi takich jak tools.sum(1,2);

możemy po prostu zadzwonić

require('tools.js')();

i wtedy

sum(1,2);

w moim przypadku mam plik ze sterownikami ctrls.js

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

i mogę używać Categoriesw każdym kontekście jako klasy publicznej porequire('ctrls.js')()


12
Jak to nie ma więcej +1? To prawdziwe rozwiązanie tego, o co pyta (choć nie „oficjalne”). Jest także milion razy łatwiejszy do debugowania niż eval (), ponieważ węzeł może podać użyteczny stos wywołań zamiast wskazywać na rzeczywisty plik zamiast po prostu niezdefiniowany.
user3413723

5
Pamiętaj, że nie możesz użyć trybu „ścisłego” w importowanym module.
David

1
@Nick Panov: genialny! Warto zauważyć, że działa to, ponieważ thisw funkcji jest zasięg globalny, gdy funkcja jest wywoływana bezpośrednio (nie jest w żaden sposób powiązana).
Udo G

3
to właśnie zmieniło moje życie, nie żart - miał plik 1000+ linii, że nie mogę się przełamać, bo zmienne różnych metod są między skorelowane i potrzebowałaby wymaga się w tym samym zakresie ... require('blah.js')();powinien pozwól mi zaimportować je wszystkie w tym samym zakresie !!! dzięki!!!
Sam Johnson

2
To świetna wskazówka! Uwaga: jeśli zadeklarujesz funkcję module.exports przy użyciu składni skrótu () => {} zamiast deklaracji funkcji standardowej () {}, to się nie powiedzie. Zajęło mi godzinę, aby dowiedzieć się, gdzie był problem! (Funkcje strzałek nie mają własnej właściwości „this”: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… )
Ryan Griggs,

117

Utwórz dwa pliki js

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

Główny plik js

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

Wyjście konsoli

Value: 30

W jakiej wersji js to działa?
Mirv - Matt

39

Oto proste i proste wyjaśnienie:

Zawartość 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);

Zawartość 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 () 
{
};

34

Szukałem również funkcji włączania NodeJS i sprawdziłem rozwiązanie zaproponowane przez Udo G - patrz komunikat https://stackoverflow.com/a/8744519/2979590 . Jego kod nie działa z moimi dołączonymi plikami JS. Wreszcie rozwiązałem problem w ten sposób:

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');

Jasne, że to pomaga.


2
Rozumiem, jaki to brzydki hack, ale na pewno mi pomógł.
lip

30

utwórz dwa pliki np. app.jsitools.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
    }

wynik

6
2

26

powiedzieć, że chce wywołać funkcję ping () i dodać (30,20) , który jest w lib.js pliku z 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
    }

1
To działa, ale czy nie powinniśmy używać składni modułów przy dołączaniu skryptów?
Kokodoko

25

Moduł vm w Node.js zapewnia możliwość wykonywania kodu JavaScript w bieżącym kontekście (w tym obiekcie globalnym). Zobacz http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_fil_filename

Zauważ, że na dzień dzisiejszy w module vm występuje błąd, który uniemożliwia runInThisContext wykonanie prawidłowej operacji po wywołaniu z nowego kontekstu. Ma to znaczenie tylko wtedy, gdy główny program wykonuje kod w nowym kontekście, a następnie wywołuje kod runInThisContext. Zobacz https://github.com/joyent/node/issues/898

Niestety sugerowane przez Fernando podejście z (globalnym) nie działa dla nazwanych funkcji, takich jak „function foo () {}”

Krótko mówiąc, oto funkcja include (), która działa dla mnie:

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

Znalazłem vm.runInThisContext w innej odpowiedzi SO i używałem go do dołączania plików kodu JavaScript „waniliowego”. Potem jednak próbowałem użyć go do włączenia kodu zależnego od funkcjonalności węzła (np. „Var fs = wymagają („ fs ”)”) i to nie działałoby. W takim przypadku jednak rozwiązanie „ewaluacyjne” wymienione w kilku odpowiedziach rzeczywiście działa.
Dexygen

Zastanawiając się nad tym nieco bardziej, kiedy zaczniesz potrzebować dołączać kod, który zależy od funkcjonalności węzła, prawdopodobnie czas napisać moduł, chociaż ewaluacyjne rozwiązanie może być pierwszym krokiem w tym procesie
Dexygen

Tylko jeden, który działał w node.js w 2019 r.
Meesern

13

Udo G. powiedział:

  • Funkcja eval () nie może być używana wewnątrz funkcji i musi być wywoływana w zakresie globalnym, w przeciwnym razie żadne funkcje lub zmienne nie będą dostępne (tj. Nie będzie można utworzyć funkcji narzędziowej include () ani czegoś takiego).

Ma rację, ale istnieje sposób, aby wpłynąć na zasięg globalny z funkcji. Poprawiając swój przykład:

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

include('somefile_with_some_declarations.js');

// the declarations are now accessible here.

Mam nadzieję, że to pomaga.


12

Działa ze mną w następujący sposób ...

Lib1.js

//Any other private code here 

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

// Again any private code

teraz w pliku Main.js musisz dołączyć Lib1.js

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

Pamiętaj, aby umieścić plik Lib1.js w folderze node_modules .


11

Możesz umieścić swoje funkcje w zmiennych globalnych, ale lepiej jest po prostu zmienić skrypt narzędzi w moduł. To naprawdę nie jest zbyt trudne - wystarczy podłączyć swój publiczny interfejs API do exportsobiektu. Spójrz na moduł eksportu Zrozumienie Node.js, aby uzyskać więcej szczegółów.


1
Przykład jest lepszy niż link
tno2007

11

Moim zdaniem innym sposobem na zrobienie tego jest wykonanie wszystkiego w pliku lib, gdy wywołasz funkcję wymagającą () za pomocą (function (/ * rzeczy tutaj * /) {}) (); robi to uczyni wszystkie te funkcje, zakres globalny, dokładnie jak eval () rozwiązanie

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');
            }
    }
})();

A potem w głównym kodzie możesz wywoływać swoje funkcje według nazw takich jak:

main.js

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

Sprawi, że ten wynik

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

Zwróć uwagę na niezdefiniowane, gdy wywołasz mój obiekt.funcFour () , będzie tak samo, jeśli załadujesz eval () . Mam nadzieję, że to pomoże :)


10

Chcę tylko dodać, na wypadek, gdybyś potrzebował tylko niektórych funkcji zaimportowanych z twoich narzędzi.js. , możesz użyć przypisania destrukcyjnego, które jest obsługiwane w node.js od wersji 6.4 - patrz node.green .


Przykład : (oba pliki znajdują się w tym samym folderze)

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));

wynik: true


Pozwala to również uniknąć przypisywania tych funkcji jako właściwości innego obiektu, jak ma to miejsce w przypadku następującego (powszechnego) przypisania:

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

gdzie musisz zadzwonić tools.isEven(10).


UWAGA:

Nie zapomnij o prefiksie nazwy pliku poprawną ścieżką - nawet jeśli oba pliki znajdują się w tym samym folderze, musisz użyć prefiksu ./

Z dokumentów Node.js :

Bez wiodących „/”, „./” lub „../” wskazujących plik, moduł musi być modułem głównym lub ładowany z folderu node_modules.


10

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 };

3

Dołącz plik i uruchom go w określonym (nieglobalnym) kontekście

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);

2

To najlepszy sposób, jaki do tej pory stworzyłem.

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();

Nadal musisz poinformować, co chcesz wyeksportować

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

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

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

2

Jak masz plik abc.txti wiele innych?

Utwórz 2 pliki: fileread.jsa fetchingfile.jsnastępnie fileread.jsnapisz ten kod:

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());
}

W fetchingfile.jsnapisać ten kod:

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());

Teraz w terminalu: $ node fetchingfile.js --file = abc.txt

Podajesz nazwę pliku jako argument, a ponadto dołącz wszystkie pliki readfile.jszamiast przekazać.

Dzięki


2

Możesz po prostu po prostu require('./filename') .

Na przykład.

// 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;

Proszę to zanotować:

  1. nie można nasłuchiwać PORT na pliku potomnym, tylko nadrzędny moduł ekspresowy ma detektor PORT
  2. Dziecko używa „Routera”, a nie nadrzędnego Express moudle.

1

Ja również szukałem opcji włączenia kodu bez pisania modułów, odpowiednio. użyj tych samych przetestowanych niezależnych źródeł z innego projektu dla usługi Node.js - i odpowiedź jmparatte zrobiła to dla mnie.

Korzyścią jest to, że nie zanieczyszczasz przestrzeni nazw, z którą nie mam problemów "use strict"; i działa dobrze.

Tutaj pełny próbka:

Skrypt do załadowania - /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'
    }

}

Mam nadzieję, że to jakoś pomogło.


1

Inna metoda przy użyciu frameworka node.js i express.js

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

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

przechowuj to w pliku js o nazwie s oraz w statystyce folderów

Teraz, aby użyć funkcji

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

1

Opracowałem dość prymitywną metodę obsługi tego szablonu szablonów HTML. Podobnie jak 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));
});

nazwa_strony.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>

Wynik załadowanej strony

<!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>

0

Jeśli chcesz skorzystać z wielu procesorów i architektury Microservice, aby przyspieszyć ... Używaj RPC zamiast rozwidlonych procesów.

Brzmi skomplikowanie, ale jest to proste, jeśli używasz ośmiornicy .

Oto przykład:

na tools.js dodaj:

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;
});

w app.js dodaj:

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));

ujawnienie - jestem autorem ośmiornicy i zbudowałem go dla mojego podobnego zastosowania, ponieważ nie mogłem znaleźć żadnych lekkich bibliotek.


0

Aby zmienić „narzędzia” w moduł, wcale nie widzę tak mocno. Mimo wszystkich innych odpowiedzi nadal polecam użycie modułu. Eksportuje:

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

Teraz musimy przypisać ten eksport do zakresu globalnego (w Twojej aplikacji | index | server.js)

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

Teraz możesz odwoływać się i wywoływać funkcję jako:

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

-3

Posługiwać się:

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

app.js:

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

1
Prawie nigdy nie powinieneś używać pełnego katalogu. Należy rozważyć użycie ścieżek względnych, takich jak:./tools.js
Matthew D Auld
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.