Question

这是node.js。

如果满足几个条件，我有一个可能成为无限循环的函数。不受信任的用户设置这些条件，因此为了这个问题的目的，请假设无限循环是不可修复的。

我还需要一种方法来阻止无限循环。

以下是我正在尝试做的一些示例代码：

var infiniteloop = false;
var condition = true
function loop () {
  while (condition) {
    console.log('hi')
    if (infiniteloop) {
      condition = false
      console.log('oh last one')
    }
  }
}

loop()

所以基于我正在尝试做的几个问题。

如果infiniteloop变量设置为true，循环会停止吗？
如何检测无限循环？每3秒检查一次就好了。
infiniteloop变量在循环时无法更改，如果它在同一进程中。我必须将变量存储在不同的进程中吗？
无论什么检测到无限循环需要生活在不同的过程中？理想情况下，同样的过程会很好但是无论什么都有效？

感谢您的帮助。

Answer 1

基于其他提案混合的解决方案：

function Worker()
{
    this.MaxIterations = 1000000;
    this.Enabled = true;    
    this.condition = true;
    this.iteration = 0;
    this.Loop = function()
    {
        if (this.condition 
            && this.Enabled 
            && this.iteration++ < this.MaxIterations)
        {
            console.log(this.iteration);
            setTimeout(this.Loop.bind(this),0);
        }
    };  
    this.Stop = function()
    {
        this.Enabled = false;
    };
}
var w = new Worker();
setTimeout(w.Loop.bind(w), 0);
setTimeout(w.Stop.bind(w), 3000);

不确定这是最佳的，但应该按预期工作。

使用setTimeout恢复循环允许主node.js事件循环处理其他事件，例如w.Stop。

Answer 2

实际上，您不需要停止无限循环。使用setImmediate

例如：

var immediateId;

function loop () {
    console.log('hi');
    immediateId = setImmediate(loop);
}

loop();

这段代码将继续说 hi ，直到你停止它为止。

//stop the loop:
clearImmediate(immediateId);

为什么要使用setImmediate

记忆消耗低，不会引起记忆韭菜;
不会抛出RangeError: Maximum call stack size exceeded;
表现很好;

此外，

我创建了这个模块，以便轻松管理无限循环：

var util = require('util');
var ee = require('events').EventEmitter;

var Forever = function() {
    ee.call(this);
    this.args = [];
};

util.inherits(Forever, ee);

module.exports = Forever;

Forever.prototype.add = function() {
    if ('function' === typeof arguments[0]) {
        this.handler = arguments[0];
        var args = Array.prototype.slice.call(arguments, 1);
        if (args.length > 0) {
            this.args = args;
        }
    } else {
        this.emit('error', new Error('when using add function, the first argument should be a function'));
        return 0;
    }
    return this;
};

Forever.prototype.run = function() {
    var handler = this.handler;
    var args = this.args;
    var that = this;

this._immediateId = setImmediate(function() {
        if (typeof handler === 'function') {

            switch (args.length) {
                // fast cases
                case 0:
                    handler.call(that);
                    that.run();
                    break;
                case 1:
                    handler.call(that, args[0]);
                    that.run();
                    break;
                case 2:
                    handler.call(that, args[0], args[1]);
                    that.run();
                    break;
                    // slower
                default:
                    handler.apply(that, args);
                    that.run();
            }
                } else {
                //no function added
                that.emit('error', new Error('no function has been added to Forever'));
            }
        });
};

Forever.prototype.stop = function() {
    if (this._immediateId !== null) {
        clearImmediate(this._immediateId);
    } else {
        this.emit('error', new Error('You cannot stop a loop before it has been started'));
    }
};

Forever.prototype.onError = function(errHandler) {
    if ('function' === typeof errHandler) {
        this.on('error', errHandler);
    } else {
        this.emit('error', new Error('You should use a function to handle the error'));
    }
    return this;
};

示例用法：

var Forever = require('path/to/this/file');
var f = new Forever();

// function to be runned
function say(content1, content2){
    console.log(content1 + content2);
}

//add function to the loop
//the first argument is the function, the rest are its arguments
//chainable api
f.add(say, 'hello', ' world!').run();

//stop it after 5s
setTimeout(function(){
    f.stop();
}, 5000);

就是这样。

Answer 3

在这种情况下，无穷大取决于循环的最大迭代次数。此代码阻止了JavaScript的单线程特性，因此除非您使用Web worker，否则无论如何都会锁定所有内容。最好不要每隔x秒检查一次，因为这段代码无论如何都会阻止执行间隔或超时，而是将它作为循环迭代的最大阈值在循环内部。

var infiniteloop = false;
var condition = true;
var loopCounter = 1;
var maxLoopIterations = 1000; 
function loop () {
  while (condition) {
    console.log('hi');
    infiniteLoop = (loopCounter >= maxLoopIterations); 
    if (infiniteloop) {
      condition = false;
      console.log('oh last one');
      break;
    }
    loopCounter++;
  }
}

Answer 4

您可以创建一个子进程（分支）以检查您的实际进程是否正在响应。如果没有响应，则分叉将向父级发送消息-杀死父级和分叉。与此类似，您可以在本要点中看到：https://gist.github.com/kevinohara80/3173692

如果您要使用Express Node.js服务器，则可以尝试中间件harakiri，它可以满足您的需求。

Answer 5

我想提出我的解决方案。就我而言，我有几个无限循环（while(true)）仅由break语句终止。很难确定是否达到了这些break语句的条件，并且该算法不是我自己开发的，因此也不可以选择完全重构。

我喜欢@JasonSebring带有循环计数器的简单解决方案。在我的情况下，只需为迭代次数设置一个限制就可以了。但是我不想将所有这些变量都插入到我的代码中，此外，我还需要一个适用于嵌套循环的解决方案。所以我想出了这个包装函数：

/**
 * Stop potential infinite loops after a certain number of iterations.
 * @param loopLimit - The maximum number of iterations before loop is aborted.
 * @param silentStop - Whether to abort the loop silently or throw an error instead.
 * @param callBack - Function representing the inner code of the loop.
 */
static finiteLoopHelper(loopLimit, silentStop, callBack) {
  let loopCounter = 0;
  let stopLoop = false;

  while (!stopLoop) {
    // Return value from the callback can invoke an early stop, like a break statement.
    stopLoop = callBack();

    loopCounter++;
    if (loopCounter >= loopLimit) {
      stopLoop = true;
      if (!silentStop) {
        throw Error(`Loop aborted after ${loopLimit} iterations.`);
      }
    }
  }
}

用法是这样的：

let someVariable = 0;

finiteLoopHelper(1000, false, () => { // this line replaces "while (true) {"
  someVariable = someCalculation();
  if (someVariable === someCondition) {
    return false; // like continue in a normal loop.
  }
  codeNotExecutedInCaseOfContinue();

  if (someVariable === someOtherCondition) {
    return true; // like break in a normal loop.
  }

  // Return value at the end can be omitted, because without it the function
  // will return undefined which also keeps the loop running.
  // return false;
});

如果循环之前有条件，则必须在箭头函数中检查该条件，并像上面的示例一样使用return true;。

由于未公开循环计数器，因此可以嵌套此解决方案，而无需为内部循环的计数器找到不同的变量名。

javascript停止无限循环

5 个答案: