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
他のすべての答えにもかかわらず、従来どおり include をnode.jsソースファイルに含めたい場合は、次のようにします。
var fs = require('fs');
// file is included here:
eval(fs.readFileSync('tools.js')+'');
- ファイルの内容をオブジェクトではなく文字列として取得するには、空の文字列連結
+''が必要です（必要に応じて.toString()を使用することもできます）。 - Eval（）を関数内で使用することはできません。グローバルスコープ内で must を呼び出す必要があります。そうしないと、関数や変数にアクセスできません（つまり、
include()ユーティリティ関数などを作成できません） 。
ほとんどの場合これは 悪い習慣 であり、代わりに モジュールを書くべきです 。しかしながら、あなたのローカルコンテキスト/名前空間の汚染があなたが本当に望むものであるというまれな状況があります。
更新2015-08-06
また、これは"use strict";（ "strict mode" の時）では動作しないことに注意してください。 "インポートされた"ファイル の関数や変数 defined にアクセスできない インポートを行うコードによって。厳密モードでは、新しいバージョンの言語標準で定義されている規則が適用されます。これが 回避 ここで説明されている解決策の別の理由かもしれません。
新しい関数も新しいモジュールも必要ありません。名前空間を使用したくない場合は、呼び出しているモジュールを実行するだけです。
tools.js内
module.exports = function() {
this.sum = function(a,b) { return a+b };
this.multiply = function(a,b) { return a*b };
//etc
}
app.js内
あるいはmyController.jsのような他の.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');
}
require('ctrls.js')()の後は、パブリッククラスとしてあらゆるコンテキストでCategoriesを使うことができます。
2つの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 ()
{
};
NodeJSの 'include'機能も探していて、 Udo G - で提案されている解決策をチェックしました 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');
確かに、それは役立ちます。
Node.jsのvmモジュールは、現在のコンテキスト（グローバルオブジェクトを含む）内でJavaScriptコードを実行する機能を提供します。 http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filenameを参照してください
本日現在、vmモジュールには、新しいコンテキストから呼び出されたときにrunInThisContextが正しい動作をしないというバグがあることに注意してください。メインプログラムが新しいコンテキスト内でコードを実行し、そのコードがrunInThisContextを呼び出す場合にのみ重要です。 https://github.com/joyent/node/issues/898 を参照してください。
残念なことに、Fernandoが提案したwith（global）アプローチは、 "function foo（）{}"のような名前付き関数に対しては機能しません。
要するに、これは私のために働くinclude（）関数です：
function include(path) {
var code = fs.readFileSync(path, 'utf-8');
vm.runInThisContext(code, path);
}
main.jsからlib.jsファイルにある関数ping（）とadd（30,20）を呼び出したいとします
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
}
ウドG.は言った：
- Eval（）は関数内で使用することはできず、グローバルスコープ内で呼び出す必要があります。そうしないと、関数や変数にアクセスできなくなります（つまり、include（）ユーティリティを作成できません）機能またはそのようなもの）。
彼はその通りですが、関数からグローバルスコープに影響を与える方法があります。彼の例を改善する：
function include(file_) {
with (global) {
eval(fs.readFileSync(file_) + '');
};
};
include('somefile_with_some_declarations.js');
// the declarations are now accessible here.
願っています、それが役立ちます。
私の考えでは、これを行うもう1つの方法は、 require（） functionを使用して （function（/ * things here * /）{}）（）;を呼び出すときにlibファイルですべてを実行することです。 これを行うと、 eval（） ソリューションとまったく同じように、これらすべての関数がグローバルスコープになります。
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（） でロードするならそれは同じになるでしょう。それが役に立てば幸い ：）
あなたはあなたの関数をグローバル変数に入れることができます、しかしあなたのツールスクリプトをただモジュールに変えることはより良い習慣です。それほど難しいことではありません。パブリックAPIをexportsオブジェクトに追加するだけです。 Node.jsのエクスポートモジュールを理解する を見てください。
tools.js からインポートした特定の関数だけが必要な場合は、追加したいだけです。その後、 destructioncturing assignment を使用します。これはバージョン以降、node.jsでサポートされます 6.4 - 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 docs ：から）
ファイルを示すための先行する '/'、 './'、または '../'がない場合、モジュールはコアモジュールであるか、またはnode_modulesフォルダーからロードされる必要があります。
この完全なサンプルコードを試してください。 app.jsのrequireメソッドを使用して、他のファイルexmain.jsの関数を含める場所にそのファイルを含める必要があります。そのファイルは、以下の例のように指定された関数を公開する必要があります。
app.js
const mainFile= require("./main.js")
var x = mainFile.add(2,4) ;
console.log(x);
var y = mainFile.multiply(2,5);
console.log(y);
main.js
const add = function(x, y){
return x+y;
}
const multiply = function(x,y){
return x*y;
}
module.exports ={
add:add,
multiply:multiply
}
出力
6
10
それは私と一緒に次のように働いた....
Lib1.js
//Any other private code here
// Code you want to export
exports.function1 = function1 (params) {.......};
exports.function2 = function2 (params) {.......};
// Again any private code
Main.js ファイルに、 Lib1.js を含める必要があります。
var mylib = requires('lib1.js');
mylib.function1(params);
mylib.function2(params);
Lib1.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);
あなたは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;
その点に注意してください：
- pORTリスナーを持つのは、親Expressモジュールのみです。
- 子供は親のExpress moudleではなく 'Router'を使用しています。
これが私がこれまでに作成した最良の方法です。
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;
abc.txtというファイルが他にもたくさんありますか？
fileread.jsとfetchingfile.jsの2つのファイルを作成し、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サービスには、別のプロジェクトからテスト済みの同じスタンドアロンのソースを使用します - そして jmparatte の答えが私のためにしました。
利点は、あなたが名前空間を汚染しない、私が"use strict";で問題を抱えていない、そしてそれがうまく機能することです。
ここで full sampleです。
ロードするスクリプト - /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'
}
}
これがどういうわけか役に立つことを願っています。
Node.jsおよびexpress.jsフレームワークを使用するときの別の方法
var f1 = function(){
console.log("f1");
}
var f2 = function(){
console.log("f2");
}
module.exports = {
f1 : f1,
f2 : f2
}
これをsという名前のjsファイルとstaticsフォルダに保存します。
今関数を使用するために
var s = require('../statics/s');
s.f1();
s.f2();
私は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>
ロードされたページ結果
<!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を使用してください。
複雑に聞こえますが、 octopus を使用すれば簡単です。
これが例です：
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));
開示 - 私はタコの作者です、そして私が軽量ライブラリを見つけることができなかったので私の同様のユースケースのために構築されたならば。
「ツール」をモジュールに変えるために、私はまったく見当たりません。他のすべての回答にもかかわらず、私はまだmodule.exportsの使用をお勧めします：
//util.js
module.exports = {
myFunction: function () {
// your logic in here
let message = "I am message from myFunction";
return message;
}
}
次に、このエクスポートをグローバルスコープに（app | index | server.jsで）割り当てる必要があります。
var util = require('./util');
これで、次のように関数を参照して呼び出すことができます。
//util.myFunction();
console.log(util.myFunction()); // prints in console :I am message from myFunction