Wie kann ich in Node.js Funktionen aus anderen Dateien "einbinden"?

Question

Nehmen wir an, ich habe eine Datei namens app.js. Ziemlich einfach:

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

Was ist, wenn ich eine Funktion in "tools.js" habe. Wie würde ich sie importieren, um sie in apps.js zu verwenden?

Oder...soll ich aus "tools" ein Modul machen und es dann voraussetzen? << Scheint schwer zu sein, ich mache lieber den einfachen Import der tools.js Datei.

Answer 1

Das ist der beste Weg, den ich bisher gefunden habe.

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

Sie müssen noch angeben, was Sie exportieren möchten

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

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

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

Answer 2

Eine andere Methode bei Verwendung von node.js und express.js-Framework

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

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

dies in einer js-Datei namens s und im Ordner statics speichern

Nun zur Verwendung der Funktion

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

Answer 3

Als ob Sie eine Datei haben abc.txt und viele mehr?

Erstellen Sie 2 Dateien: fileread.js y fetchingfile.js , dann in fileread.js diesen Code schreiben:

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

En fetchingfile.js diesen Code schreiben:

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

Jetzt, in einem Terminal: $ node fetchingfile.js --file=abc.txt

Sie übergeben den Dateinamen als Argument, außerdem schließen Sie alle Dateien in readfile.js anstatt sie zu übergeben.

Gracias

Answer 4

Aus "Tools" ein Modul zu machen, sehe ich überhaupt nicht schwierig. Trotz aller anderen Antworten würde ich immer noch die Verwendung von module.exports empfehlen:

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

Nun müssen wir diese Exporte dem globalen Bereich zuweisen (in Ihrer app|index|server.js )

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

Jetzt können Sie die Funktion als referenzieren und aufrufen:

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

Answer 5

Ich war auch auf der Suche nach einer Möglichkeit, Code einzubinden, ohne Module zu schreiben, bzw. die gleichen getesteten Standalone-Quellen aus einem anderen Projekt für einen Node.js-Dienst zu verwenden - und jmparatte s Antwort hat mich überzeugt.

Der Vorteil ist, dass man den Namensraum nicht verschmutzt, ich habe keine Probleme mit "use strict"; und es funktioniert gut.

Hier ein vollständig Probe:

Zu ladendes Skript - /lib/foo.js

"use strict";

(function(){

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

    Foo.prototype.x = 1;

    return Foo;

}())

BeispielModul - 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'
    }

}

Ich hoffe, das war irgendwie hilfreich.