在浏览器中，我们可以从 javascript 字符串中创建 worker，如下所示:

var blob = new Blob([sourceString]);
var url = window.URL.createObjectURL(blob);
var worker = new Worker(url);

有没有办法用 Node 的child process 来做到这一点？ ?我有一个 JavaScript 文件，我想创建动态编码的工作线程。

源字符串是在运行时动态创建的。

我找到的最接近的答案是 this one ，但它需要一个单独的文件。

最佳答案

如果我没听错的话，我创建了 a module昨天就是这样。

它的目的不是从字符串创建 worker ，而是从实际函数创建 worker ，因为实际的函数代码必须通过思想消息传递，它们被字符串化以在 worker 内部重建(思想 eval())。

这是通过代码完成的:

var source = fn.toString();

...所以，拥有该字符串原型(prototype)也有一个 .toString() 方法，将函数作为字符串传递也必须有效(实际上有效。我刚刚测试过)。

它可能不是你想要的:如果你需要在工作人员之间传入和传出消息，这个模块不适合你。但是你可以看到the code并对其进行修改以满足您的需要。

另一方面，如果你只想在后台执行一些函数并获得结果，它比处理工作管道要简单得多，因为你可以将参数传递给函数并像一个简单的函数一样获得结果打电话。

示例:

// Reauires funwork (`npm install --save funwork`)

var funwork = require("funwork");
var workerfn = funwork(function_src_string); // or actual function.

它的缺点是必须通过 eval() 评估该函数，但是在您的情况下，(具有字符串源)我认为无论如何这是必须的。

编辑:这是 funwork 的修改版本，可以满足我们在评论中讨论的您想要的效果:

var Worker = require('webworker-threads').Worker;
var Deasync = require('deasync');

function strWorker(fn){

    var source = fn.toString();

    return function() {

        var done = false;
        var args = Array.prototype.slice.call(arguments);
        var error;

        // Create worker://{{{
        var worker = new Worker(function(){
            var fn;
            var me = this;

            // Wait for function source and arguments:
            me.onmessage = function(event) {
                switch (event.data.oper) {
                    case "src":
                        // "Compile" function thougt source evaluation.
                        try {
                            eval ("fn = " + event.data.msg + ";");
                            postMessage(['ready']);
                        } catch (e) {
                            postMessage(['error', "Error trying to evaluate function source"]);
                        };
                        break;
                    case "args":
                        // Call the function with given arguments and reset the rest of worker stuff.
                        try {
                            // Reset worker (inside) event handler:
                            delete me.onmessage;

                            // Notify that worker is ready:
                            postMessage(["ok"]);

                            // Start function execution:
                            fn.apply(me, event.data.msg);

                        } catch (e) {
                            postMessage(['error', e]);
                        };
                        break;
                };
            };
        });//}}}

        // Event handling://{{{
        worker.onmessage = function(event) {
            switch (event.data[0]) {
                case 'error':
                    worker.postMessage({oper: "end"});
                    done = true;
                    error = event.data[1];
                    break;
                case 'ready':
                    worker.postMessage({oper: "args", msg: args});
                    break;
                case 'ok':
                    done = true;
                    break;
            };
        };//}}}

        // Send function source to worker:
        worker.postMessage({oper: "src", msg: source});

        // Wait (without blocking) until worker executed passed function:
        Deasync.loopWhile(function(){return !done;});

        if (error) throw error;

        // Reset worker (outside) event handler:
        delete worker.onmessage;

        return worker;
    };

};

module.exports = strWorker;

我保留了向函数传递参数的能力，因为它已经实现了，如果你不需要传递任何东西，你可以简单地不使用它。

用法相同，唯一区别是生成的函数返回的是正在运行的worker而不是函数返回值。

在函数(作为字符串传入)执行和worker返回之前分别删除使用的事件处理程序(在worker内部和外部)，以避免任何副作用和传入的执行上下文(“this”)函数也设置为实际的 worker “父”函数。 .

关于javascript - 如何从字符串创建子进程，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45106914/