将“ Vanilla” Javascript库加载到Node.js中

我希望在Node.js服务器中使用某些具有某些功能的第三方Javascript库。（特别是我想使用找到的QuadTree javascript库。）但是这些库只是简单的.js文件，而不是“ Node.js库”。

因此，这些库不遵循exports.var_nameNode.js对其模块期望的语法。据我了解，这意味着当您这样做时，module = require('module_name');或者module = require('./path/to/file.js');最终将得到一个没有公共可访问功能的模块，等等。

然后我的问题是“我如何将一个任意的javascript文件加载到Node.js中，这样我就可以利用其功能而不必重写它就可以了exports？”

我对Node.js还是很陌生，所以请让我知道我对它的工作方式是否有明显的了解。

编辑：进行了更多的研究，现在我看到Node.js使用的模块加载模式实际上是最近开发的用于加载称为CommonJS的 Javascript库的标准的一部分。它在Node.js的模块文档页面上说得很对，但是直到现在我都没想到。

我的问题的答案可能最终是“等到您的库的作者开始写CommonJS接口或自己做的那样做。”

有比使用eval：vm模块更好的方法。

例如，这是我的execfile模块，该模块path在context或全局上下文中评估脚本：

var vm = require("vm");
var fs = require("fs");
module.exports = function(path, context) {
  context = context || {};
  var data = fs.readFileSync(path);
  vm.runInNewContext(data, context, path);
  return context;
}

可以这样使用：

> var execfile = require("execfile");
> // `someGlobal` will be a global variable while the script runs
> var context = execfile("example.js", { someGlobal: 42 });
> // And `getSomeGlobal` defined in the script is available on `context`:
> context.getSomeGlobal()
42
> context.someGlobal = 16
> context.getSomeGlobal()
16

其中example.js包含：

function getSomeGlobal() {
    return someGlobal;
}

此方法的最大优点是，您可以完全控制已执行脚本中的全局变量：您可以传入自定义全局变量（通过context），并且脚本创建的所有全局变量都将添加到中context。调试也更加容易，因为将使用正确的文件名报告语法错误等。

对于这种情况，我认为这是“最正确的”答案。

假设您有一个名为的脚本文件quadtree.js。

您应该构建node_module具有这种目录结构的自定义...

./node_modules/quadtree/quadtree-lib/
./node_modules/quadtree/quadtree-lib/quadtree.js
./node_modules/quadtree/quadtree-lib/README
./node_modules/quadtree/quadtree-lib/some-other-crap.js
./node_modules/quadtree/index.js

./node_modules/quadtree/quadtree-lib/目录中的所有内容都是来自第3方库的文件。

然后，您的./node_modules/quadtree/index.js文件将只从文件系统中加载该库，并完成正确导出内容的工作。

var fs = require('fs');

// Read and eval library
filedata = fs.readFileSync('./node_modules/quadtree/quadtree-lib/quadtree.js','utf8');
eval(filedata);

/* The quadtree.js file defines a class 'QuadTree' which is all we want to export */

exports.QuadTree = QuadTree

现在，您可以quadtree像其他任何节点模块一样使用模块了。

var qt = require('quadtree');
qt.QuadTree();

我喜欢这种方法，因为无需更改您的第3方库的任何源代码，因此维护起来更容易。升级所需要做的只是查看其源代码，并确保您仍在导出正确的对象。

最简单的方法是：eval(require('fs').readFileSync('./path/to/file.js', 'utf8')); 这非常适合在交互式shell中进行测试。

AFAIK，确实是必须加载模块的方式。但是，除了将所有导出的函数附加到exports对象上之外，您还可以将它们附加到this（否则将是全局对象）上。

因此，如果要保持其他库兼容，可以执行以下操作：

this.quadTree = function () {
  // the function's code
};

或者，当外部库已经有自己的名称空间时（例如jQuery（不是您可以在服务器端环境中使用它））：

this.jQuery = jQuery;

在非节点环境中，this将解析为全局对象，从而使其成为全局变量……已经是。因此，它不应破坏任何内容。

编辑：詹姆斯·赫德曼（James Herdman）对于初学者有一个不错的关于node.js的文章，其中也提到了这一点。

我不确定我是否最终会使用它，因为这是一个非常棘手的解决方案，但是解决此问题的一种方法是构建一个像这样的小微型模块导入器...

在文件中./node_modules/vanilla.js：

var fs = require('fs');

exports.require = function(path,names_to_export) {
    filedata = fs.readFileSync(path,'utf8');
    eval(filedata);
    exported_obj = {};
    for (i in names_to_export) {
        to_eval = 'exported_obj[names_to_export[i]] = ' 
            + names_to_export[i] + ';'
        eval(to_eval); 
    }
    return exported_obj;
}

然后，当您要使用库的功能时，需要手动选择要导出的名称。

所以对于像文件这样的库./lib/mylibrary.js...

function Foo() { //Do something... }
biz = "Blah blah";
var bar = {'baz':'filler'};

当您想在Node.js代码中使用其功能时...

var vanilla = require('vanilla');
var mylibrary = vanilla.require('./lib/mylibrary.js',['biz','Foo'])
mylibrary.Foo // <-- this is Foo()
mylibrary.biz // <-- this is "Blah blah"
mylibrary.bar // <-- this is undefined (because we didn't export it)

不过，不知道这在实践中将如何运作。

我可以很容易地通过更新他们的脚本来使其工作，只需module.exports =在适当的地方添加...

例如，我拿走了他们的文件，然后将其复制到“ ./libs/apprise.js”。然后从哪里开始

function apprise(string, args, callback){

我将功能分配给了module.exports =：

module.exports = function(string, args, callback){

因此，我可以像这样将库导入到我的代码中：

window.apprise = require('./libs/apprise.js');

而且我很好走。YMMV，这是webpack的。

一个简单的include(filename)函数，具有更好的错误消息传递（堆栈，文件名等）eval，以防发生错误：

var fs = require('fs');
// circumvent nodejs/v8 "bug":
// https://github.com/PythonJS/PythonJS/issues/111
// http://perfectionkills.com/global-eval-what-are-the-options/
// e.g. a "function test() {}" will be undefined, but "test = function() {}" will exist
var globalEval = (function() {
    var isIndirectEvalGlobal = (function(original, Object) {
        try {
            // Does `Object` resolve to a local variable, or to a global, built-in `Object`,
            // reference to which we passed as a first argument?
            return (1, eval)('Object') === original;
        } catch (err) {
            // if indirect eval errors out (as allowed per ES3), then just bail out with `false`
            return false;
        }
    })(Object, 123);
    if (isIndirectEvalGlobal) {
        // if indirect eval executes code globally, use it
        return function(expression) {
            return (1, eval)(expression);
        };
    } else if (typeof window.execScript !== 'undefined') {
        // if `window.execScript exists`, use it
        return function(expression) {
            return window.execScript(expression);
        };
    }
    // otherwise, globalEval is `undefined` since nothing is returned
})();

function include(filename) {
    file_contents = fs.readFileSync(filename, "utf8");
    try {
        //console.log(file_contents);
        globalEval(file_contents);
    } catch (e) {
        e.fileName = filename;
        keys = ["columnNumber", "fileName", "lineNumber", "message", "name", "stack"]
        for (key in keys) {
            k = keys[key];
            console.log(k, " = ", e[k])
        }
        fo = e;
        //throw new Error("include failed");
    }
}

但是使用nodejs甚至会更加肮脏：您需要指定以下内容：

export NODE_MODULE_CONTEXTS=1
nodejs tmp.js

否则，您将无法在包含的文件中使用全局变量include(...)。