Laden node.js Modul von Strings im Speicher

Ist die Frage schon beantwortet Andrej, aber ich lief in ein Manko, das ich zu lösen hatte, und die von Interesse sein könnten für andere.

Wollte ich das Modul in den gespeicherten string zu können, laden Module über require, aber der Modul-Pfad gebrochen wurde mit der obigen Lösung (so z.B. Nadel wurde nicht gefunden).
Ich habe versucht zu finden, eine elegante Lösung zur Aufrechterhaltung der Pfade, die über einen vorhandenen Funktion, aber ich landete mit harte Verdrahtung der Pfade:

function requireFromString(src, filename) {
  var m = new module.constructor();
  m.paths = module.paths;
  m._compile(src, filename);
  return m.exports;
}

var codeString = 'var needle = require(\'needle\');\n'
  + '[...]\n'
  + 'exports.myFunc = myFunc;';

var virtMod = requireFromString(codeString);
console.log('Available public functions: '+Object.keys(virtMod));

Danach war ich in der Lage das laden aller vorhandenen Module aus dem stringified-Modul.
Irgendwelche Kommentare oder bessere Lösungen sehr geschätzt!

InformationsquelleAutor Dominic

Basierend auf Andrej sidorowym & Dominic Lösungen, die ich war traurig über die Tatsache, nicht in der Lage zu verlangen, ein stringified-Modul, dann schlage ich vor, diese version *.

Code:

void function() {
    'use strict';

    const EXTENSIONS = ['.js', '.json', '.node'];

    var Module,
        path,
        cache,
        resolveFilename,
        demethodize,
        hasOwnProperty,
        dirname,
        parse,
        resolve,
        stringify,
        virtual;

    Module = require('module');
    path = require('path');

    cache = Module._cache;
    resolveFilename = Module._resolveFilename;

    dirname = path.dirname;
    parse = path.parse;
    resolve = path.resolve;
    demethodize = Function.bind.bind(Function.call);
    hasOwnProperty = demethodize(Object.prototype.hasOwnProperty);

    Module._resolveFilename = function(request, parent) {
        var filename;

        //Pre-resolution
        filename = resolve(parse(parent.filename).dir, request);

        //Adding extension, if needed
        if (EXTENSIONS.indexOf(parse(filename).ext) === -1) {
            filename += '.js';
        }

        //If the module exists or is virtual, return the filename
        if (virtual || hasOwnProperty(cache, filename)) {
            return filename;
        }

        //Preserving the native behavior
        return resolveFilename.apply(Module, arguments);
    };

    Module._register = function(request, parent, src) {
        var filename,
            module;

        //Enabling virtual resolution
        virtual = true;

        filename = Module._resolveFilename(request, parent);

        //Disabling virtual resolution
        virtual = false;

        //Conflicts management
        if (hasOwnProperty(cache, filename)) {
            error = new Error('Existing module "' + request + '"');
            error.code = 'MODULE_EXISTS';

            throw error;
        }

        //Module loading
        cache[filename] = module = new Module(filename, parent);
        module.filename = filename;
        module.paths = Module._nodeModulePaths(dirname(filename));
        module._compile(stringify(src), filename);
        module.loaded = true;

        return module;
    };

    stringify = function(src) {
        //If src is a function, turning to IIFE src
        return typeof src === 'function'
            ? 'void ' + src.toString() + '();'
            : src;
    };
}();

void function() {
    var Module,
        parentModule,
        child;

    Module = require('module');

    //Creating a parent module from string
    parentModule = Module._register('parent', process.mainModule, `
        module.exports = {
            name: module.filename,
            getChild: function() {
                return require('child');
            }
        };
    `);

    //Creating a child module from function
    Module._register('child', parentModule, function() {
        module.exports = {
            name: module.filename,
            getParent: function() {
                return module.parent.exports;
            }
        };
    });

    child = require('child');

    console.log(child === child.getParent().getChild());
}();

Verwendung:

void function() {
    var Module,
        parentModule,
        child;

    Module = require('module');

    //Creating a parent module from string
    parentModule = Module._register('parent', process.mainModule, `
        module.exports = {
            name: module.filename,
            getChild: function() {
                return require('child');
            }
        };
    `);

    //Creating a child module from function
    Module._register('child', parentModule, function() {
        module.exports = {
            name: module.filename,
            getParent: function() {
                return module.parent.exports;
            }
        };
    });

    child = require('child');

    console.log(child === child.getParent().getChild());
}();

* wie Sie sehen können, enthält es eine Funktion formater, die bietet eine Möglichkeit zu schaffen, einige Module von Funktionen.

InformationsquelleAutor Lcf.vs

Ich denke, der bessere Weg, um diesen Ansatz wäre es, einen parameter, den Sie festlegen können danach...

wie in der Datei: myUnalteredModule.js

exports.setChanges = function( args )...

Dann könnten Sie tun:

 var loadedModule = require( 'myUnalteredModule' );
loadedModule

InformationsquelleAutor Borrey