Charger les bibliothèques Javascript «Vanilla» dans Node.js

Il existe des bibliothèques Javascript tierces qui ont des fonctionnalités que je voudrais utiliser dans un serveur Node.js. (Plus précisément, je veux utiliser une bibliothèque javascript QuadTree que j'ai trouvée.) Mais ces bibliothèques ne sont que des .jsfichiers simples et non des "bibliothèques Node.js".

En tant que telles, ces bibliothèques ne suivent pas la exports.var_namesyntaxe attendue par Node.js pour ses modules. Pour autant que je sache, cela signifie quand vous faites module = require('module_name');ou module = require('./path/to/file.js');vous vous retrouverez avec un module sans fonctions accessibles au public, etc.

Ma question est alors "Comment charger un fichier javascript arbitraire dans Node.js de manière à pouvoir utiliser ses fonctionnalités sans avoir à le réécrire pour qu'il le fasse exports?"

Je suis très nouveau sur Node.js, alors faites-moi savoir s'il y a un trou flagrant dans ma compréhension de son fonctionnement.

EDIT : En recherchant davantage et je vois maintenant que le modèle de chargement de module utilisé par Node.js fait en fait partie d'un standard récemment développé pour le chargement de bibliothèques Javascript appelé CommonJS . Il dit cela directement sur la page de documentation du module pour Node.js , mais je l'ai manqué jusqu'à présent.

Il se peut que la réponse à ma question soit "attendez que les auteurs de votre bibliothèque se mettent à écrire une interface CommonJS ou faites-le vous-même".

Il existe une bien meilleure méthode que d'utiliser eval: le vmmodule.

Par exemple, voici mon execfilemodule, qui évalue le script pathdans l'un contextou l'autre contexte global:

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

Et il peut être utilisé comme ceci:

> 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

Où example.jscontient:

function getSomeGlobal() {
    return someGlobal;
}

Le gros avantage de cette méthode est que vous avez un contrôle complet sur les variables globales dans le script exécuté: vous pouvez passer des globaux personnalisés (via context), et tous les globaux créés par le script seront ajoutés context. Le débogage est également plus facile car les erreurs de syntaxe et autres seront signalées avec le nom de fichier correct.

Voici ce que je pense être la réponse «la plus juste» à cette situation.

Supposons que vous ayez un fichier de script appelé quadtree.js.

Vous devez créer une personnalisation node_modulequi a ce type de structure de répertoires ...

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

Tout ce qui se trouve dans votre ./node_modules/quadtree/quadtree-lib/répertoire est constitué de fichiers de votre bibliothèque tierce.

Ensuite, votre ./node_modules/quadtree/index.jsfichier chargera simplement cette bibliothèque à partir du système de fichiers et effectuera le travail d'exportation des choses correctement.

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

Vous pouvez maintenant utiliser votre quadtreemodule comme n'importe quel autre module de nœud ...

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

J'aime cette méthode car il n'est pas nécessaire de changer le code source de votre bibliothèque tierce - c'est donc plus facile à maintenir. Tout ce que vous avez à faire lors de la mise à niveau est de consulter leur code source et de vous assurer que vous exportez toujours les objets appropriés.

Le moyen le plus simple est: eval(require('fs').readFileSync('./path/to/file.js', 'utf8')); Cela fonctionne très bien pour les tests dans le shell interactif.

AFAIK, c'est bien ainsi que les modules doivent être chargés. Cependant, au lieu de coller toutes les fonctions exportées sur l' exportsobjet, vous pouvez également les coller sur this(ce qui serait autrement l'objet global).

Donc, si vous souhaitez garder les autres bibliothèques compatibles, vous pouvez le faire:

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

ou, lorsque la bibliothèque externe a déjà son propre espace de noms, par exemple jQuery(pas que vous pouvez utiliser que dans un environnement côté serveur):

this.jQuery = jQuery;

Dans un environnement non-Node, thisse résoudrait à l'objet global, en faisant ainsi une variable globale ... ce qu'il était déjà. Donc ça ne devrait rien casser.

Edit : James Herdman a un bel article sur node.js pour les débutants, qui le mentionne également.

Je ne sais pas si je finirai par l'utiliser car c'est une solution plutôt pirate, mais une solution consiste à créer un petit importateur de mini-modules comme celui-ci ...

Dans le fichier ./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;
}

Ensuite, lorsque vous souhaitez utiliser les fonctionnalités de votre bibliothèque, vous devez choisir manuellement les noms à exporter.

Donc pour une bibliothèque comme le fichier ./lib/mylibrary.js...

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

Lorsque vous souhaitez utiliser ses fonctionnalités dans votre code 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)

Je ne sais pas si tout cela fonctionnerait dans la pratique.

J'ai pu le faire fonctionner en mettant à jour leur script, très facilement, en ajoutant simplement le module.exports =cas échéant ...

Par exemple, j'ai pris leur fichier et j'ai copié dans './libs/apprise.js'. Alors où ça commence par

function apprise(string, args, callback){

J'ai assigné la fonction à module.exports =ainsi:

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

Ainsi, je suis capable d'importer la bibliothèque dans mon code comme ceci:

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

Et j'étais prêt à partir. YMMV, c'était avec webpack .

Une include(filename)fonction simple avec une meilleure messagerie d'erreur (pile, nom de fichier etc.) pour eval, en cas d'erreurs:

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

Mais cela devient encore plus sale avec nodejs: vous devez spécifier ceci:

export NODE_MODULE_CONTEXTS=1
nodejs tmp.js

Sinon, vous ne pouvez pas utiliser de variables globales dans les fichiers inclus avec include(...).