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

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.

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

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.

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

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

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

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.

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

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
    }

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

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.

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 .

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.

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

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.

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

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

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;

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

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.

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.

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

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>

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.

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 

Posługiwać się:

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

app.js:

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