Node.js'de, diğer dosyalarımdaki işlevleri nasıl “dahil ederim”?

Diyelim ki app.js adlı bir dosyam var. Gayet basit:

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" içinde bir işlevim varsa ne olur. Bunları apps.js'de kullanmak için nasıl içe aktarırım?

Ya da ... "araçları" bir modüle dönüştürmem ve daha sonra buna ihtiyacım var mı? << zor görünüyor, ben tools.js dosyasının temel ithalat yapmak istiyorum.

Herhangi bir js dosyasına ihtiyacınız olabilir, sadece ne göstermek istediğinizi beyan etmeniz gerekir.

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

var zemba = function () {
}

Ve uygulama dosyanızda:

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

Diğer tüm yanıtlara rağmen, geleneksel olarak bir node.js kaynak dosyasına bir dosya eklemek istiyorsanız , bunu kullanabilirsiniz:

var fs = require('fs');

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

• Boş dize birleştirmesi +'', dosya içeriğini bir nesne olarak değil, bir dize olarak almak için gereklidir (isterseniz de kullanabilirsiniz .toString()).
• Eval () bir işlev içinde kullanılamaz ve gereken başka türlü hiçbir işlevleri veya değişkenler (bir oluşturamazsınız sizi yani erişilebilir olacaktır küresel kapsamı içine çağrılabilir include()böyle fayda fonksiyonu ya da bir şey).

Çoğu durumda bunun kötü bir uygulama olduğunu ve bunun yerine bir modül yazmanız gerektiğini lütfen unutmayın . Bununla birlikte, yerel bağlam / ad alanınızın kirlenmesinin gerçekten istediğiniz şey olduğu nadir durumlar vardır.

Güncelleme 2015-08-06

Ayrıca , "içe aktarılan" dosyada tanımlanan işlevlere ve değişkenlere içe aktarmayı yapan kodla erişilemediğinden"use strict"; ( "katı modda" olduğunuzda ) bunun işe yaramayacağını da unutmayın . Katı mod, dil standardının daha yeni sürümleri tarafından tanımlanan bazı kuralları uygular. Bu, burada açıklanan çözümü önlemek için başka bir neden olabilir .

Yeni işlevlere veya yeni modüllere ihtiyacınız yoktur. Ad alanını kullanmak istemiyorsanız, aradığınız modülü yürütmeniz yeterlidir.

tools.js dosyasında

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

app.js içinde

veya myController.js gibi diğer .js dosyalarında:

onun yerine

var tools = require('tools.js') bizi bir ad alanı kullanmaya ve tools.sum(1,2);

sadece arayabiliriz

require('tools.js')();

ve sonra

sum(1,2);

benim durumumda ctrls.js denetleyicilerine sahip bir dosyam var

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

ve Categoriesher bağlamda kamu sınıfı olarak kullanabilirimrequire('ctrls.js')()

İki js dosyası oluştur

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

Ana js dosyası

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

Konsol Çıkışı

Value: 30

İşte basit ve basit bir açıklama:

Server.js içeriği:

// 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 içeriği:

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

Ayrıca bir NodeJS 'include' işlevi arıyordum ve Udo G tarafından önerilen çözümü kontrol ettim - https://stackoverflow.com/a/8744519/2979590 mesajına bakın . Kodu dahil edilen JS dosyalarımla çalışmıyor. Sonunda sorunu şöyle çözdüm:

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

Elbette, bu yardımcı olur.

iki dosya örneğin oluşturmak app.jsvetools.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
    }

çıktı

6
2

demek biz işlevi aramak istiyor ping () ve (30,20) ekleyin içinde olan lib.js dosyanın 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'deki vm modülü, geçerli bağlamda (genel nesne dahil) JavaScript kodunu yürütme olanağı sağlar. Bkz. Http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filename

Bugün itibariyle, vm modülünde runInThisContext öğesinin yeni bir bağlamdan çağrıldığında doğru işlemi yapmasını engelleyen bir hata olduğunu unutmayın. Bu, yalnızca ana programınız kodu yeni bir bağlam içinde yürütüyorsa ve bu kod runInThisContext'i çağırıyorsa önemlidir. Bkz. Https://github.com/joyent/node/issues/898

Ne yazık ki, Fernando'nun önerdiği with (global) yaklaşım, "function foo () {}" gibi adlandırılmış işlevler için çalışmaz

Kısacası, işte benim için çalışan bir include () işlevi:

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

Udo G. şöyle dedi:

• Eval () bir işlev içinde kullanılamaz ve genel kapsam içinde çağrılmalıdır, aksi takdirde hiçbir işleve veya değişkene erişilemez (yani bir include () yardımcı programı işlevi veya bunun gibi bir şey oluşturamazsınız).

Haklı, ancak küresel kapsamı bir işlevden etkilemenin bir yolu var. Örneğini geliştirmek:

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

include('somefile_with_some_declarations.js');

// the declarations are now accessible here.

Umarım yardımcı olur.

Aşağıdaki gibi benimle çalıştı ....

Lib1.js

//Any other private code here 

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

// Again any private code

şimdi Main.js dosyasında Lib1.js dosyasını eklemeniz gerekir

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

Lütfen Lib1.js dosyasını node_modules klasörüne koymayı unutmayın .

İşlevlerinizi global değişkenlere koyabilirsiniz, ancak araçlar komut dosyanızı bir modüle dönüştürmek daha iyi bir uygulamadır. Gerçekten çok zor değil - genel API'nızı exportsnesneye eklemeniz yeterlidir. Daha ayrıntılı bilgi için Undersde Node.js'nin dışa aktarma modülüne göz atın .

Bence bunu yapmanın bir başka yolu, sen çağrı zaman lib dosyasındaki herşeyi yürütmektir gerektirir () fonksiyonu kullanılarak (function (burada / * şeyler * /) {}) (); bunu yapmak, bu eval () çözümü gibi tüm bu fonksiyonları global kapsam haline getirecektir.

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

Ve sonra ana kodunuzda işlevlerinizi aşağıdaki gibi adlarla arayabilirsiniz:

main.js

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

Bu çıktıyı yapacak

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

İçin Öde Atention tanımsız sen benim çağrı object.funcFour () Birlikte yüklerseniz, bu aynı olacaktır eval () . Umarım yardımcı olur :)

Her ihtimale karşı size ithal sadece belirli işlevleri gerekmez, eklemek istediğiniz tools.js o zaman bir kullanabilir, yapı bozma ataması sürümü beri node.js desteklenir 6.4 - bkz node.green .

Örnek : (her iki dosya da aynı klasördedir)

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

çıktı: true

Bu, bu işlevleri aşağıdaki (ortak) atamada olduğu gibi başka bir nesnenin özellikleri olarak atamanızı da önler:

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

aramanız gereken yer tools.isEven(10).

NOT:

Dosya adınızı doğru yolla önek olarak eklemeyi unutmayın - her iki dosya da aynı klasörde olsa bile, ./

Gönderen node.js docs :

Bir dosyayı belirtmek için önde gelen '/', './' veya '../' olmadan modül ya bir çekirdek modül olmalı ya da bir düğüm_modülleri klasöründen yüklenmelidir.

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

Dosyayı dahil et ve verilen (global olmayan) bağlamda çalıştır

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

Bu şimdiye kadar yarattığım en iyi yol.

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

Neyi dışa aktarmak istediğinizi bildirmeniz gerekiyor

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

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

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

Sanki bir dosyaya abc.txtve daha fazlasına sahip misin?

2 dosya oluşturun: fileread.jsve fetchingfile.jssonra fileread.jsbu kodu yazın:

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

Gelen fetchingfile.jsyazma Bu 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());

Şimdi, bir terminalde: $ node fetchingfile.js --file = abc.txt

Dosya adını bağımsız değişken olarak geçiriyorsunuz, üstelik tüm dosyaları da readfile.jsgeçirmek yerine dahil ediyorsunuz .

Teşekkürler

Sadece basit require('./filename').

Örneğin.

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

Lütfen bunu not al:

1. PORT'u alt dosyada dinleyemezsiniz, yalnızca üst ekspres modülünde PORT dinleyici bulunur
2. Çocuk üst Express moudle'ı değil, 'Yönlendirici' kullanıyor.

Ben de modülleri yazmadan kodu dahil etmek için bir seçenek arıyordu, resp. Node.js hizmeti için farklı bir projedeki aynı test edilmiş bağımsız kaynakları kullanın ve jmparatte'nin cevabı benim için yaptı.

Yararı, isim alanını kirletmemeniz, sorunum yok "use strict";ve iyi çalışıyor.

İşte tam bir örnek:

Yüklenecek komut dosyası - /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'
    }

}

Umarım bu bir şekilde yardımcı olmuştur.

Node.js ve express.js çerçevesini kullanırken başka bir yöntem

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

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

bunu s adında bir js dosyasında ve klasör istatistiklerinde depola

Şimdi işlevi kullanmak için

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

Ben HTML şablonlama için bu işleme oldukça kaba bir yöntem ile geldim. PHP'ye benzer<?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>

Yüklenen Sayfa Sonucu

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

Birden fazla CPU ve Microservice mimarisinden yararlanmak istiyorsanız, işleri hızlandırmak için ... Çatallı işlemler üzerinde RPC kullanın.

Kulağa karmaşık geliyor, ancak ahtapot kullanıyorsanız basit .

İşte bir örnek:

tools.js'de ekleyin:

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 üzerinde şunu ekleyin:

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

açıklama - Ben ahtapot yazarı ve benzer bir usecase için inşa, çünkü herhangi bir hafif kütüphane bulamadı.

"Aletleri" bir modüle dönüştürmek için hiç zor görmüyorum. Diğer tüm cevaplara rağmen hala module.exports kullanılmasını öneriyorum:

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

Şimdi bu dışa aktarmaları global kapsama atamamız gerekiyor (uygulamanız | index | server.js)

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

Artık işlevi şu şekilde arayabilir ve çağırabilirsiniz:

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

kullanın:

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

app.js:

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