recursive function vs setInterval vs setTimeout ja

问题:

i am using NodeJs and need call a infinite function, but i dont know what is the best for a optimal performance.

recursive function

function test(){
//my code
test();
}

setInterval

setInterval(function(){
//my code
},60);

setTimeout

function test(){
//my code
setTimeout(test,60);
}

I want the best performance without collapse the server. My code have several arithmetic operations.

appreciate any suggestions to optimize the javascript performance.

回答1:

Be carefull.. your first code would block JavaScript event loop.

Basically in JS is something like list of functions which should be processed. When you call setTimeout, setInterval or process.nextTick you will add given function to this list and when the right times comes, it will be processed..

Your code in the first case would never stop so it would never let another functions in the event list to be processed.

Second and third case is good.. with one little difference.

If your function takes to process for example 10ms and interval will be yours 60ms..

• function with setInterval will be processed in times: 0-10, 60-70, 120-130, ... (so it has only 50ms delay between calls)
• But with setTimeout it will be:
  • if you call func first: 0-10, 70-80, 140-150, 210-220, ...
  • if you call setTimeout first: 60-70, 130-140, 200-210, ...

So the difference is delay between starts of your function which can be important in some interval based systems, like games, auctions, stock market.. etc..

Good luck with your recursion :-)

回答2:

As already mentioned, endless recursive functions lead to a stack overflow. Time triggered callbacks will be executed in an own context with a clear stack.

setInterval is useful for more accurate periodic calls over recursive setTimeout, however, there is a drawback: The callback will be triggered even if an uncaught exception was thrown. This usually produces a several bytes long log entry every 60 milliseconds, 1'440'000 entries per day. Furthermore a setInterval callback with heavy load could end up in an unresponsive script or even hole system.

Recursive setTimeout immediate before return from function will not be executed if any exception hasn't been caught. It will guarantee a time frame for other tasks after return from the callback function independent of the function's execution time.

回答3:

Not sure what you're trying to accomplish, but here's a "safe" way to use recursion... https://stackoverflow.com/questions/24208676/how-to-use-recursion-in-javascript/24208677

/*
this will obviously crash... and all recursion is at risk of running out of call stack and breaking your page...

function recursion(c){
    c = c || 0;
    console.log(c++);
    recursion(c);
}
recursion();

*/

// add a setTimeout to reset the call stack and it will run "forever" without breaking your page!
// use chrome's heap snapshot tool to prove it to yourself.  :)

function recursion(c){
    setTimeout(function(c){
        c = c || 0;
        console.log(c++);
        recursion(c);
    },0,c);
}

recursion();

// another approach is to use event handlers, but that ultimately uses more code and more resources

回答4:

Assuming the "perfomance delay" described by Jan Juna, I have tried this simple script to check if there are any differences in terms of throughput:

Interval:

const max = 50;
const timer = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 100, 150, 200, 250, 300, 400, 500];

function crono(timer) {
  return new Promise(resolve => {
    const exit = [];
    let i = 0
    setInterval(() => i++, timer);

    setInterval(() => {
      exit.push(i);
      i = 0;
      if (exit.length === max) {
        const sum = exit.reduce((a, b) => (a + b), 0);
        const avg = sum / exit.length;
        console.log(`${timer} = ${avg}`);
        resolve(avg)
      }
    }, 1000);
  });
}

Promise.all(timer.map(crono)).then(process.exit);

Timeout:

const max = 50;
const timer = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 100, 150, 200, 250, 300, 400, 500];

function crono(timer) {
  return new Promise(resolve => {
    const exit = [];
    let i = 0

    const redo = () => {
      i++
      setTimeout(redo, timer);
    }

    setInterval(() => {
      exit.push(i);
      i = 0;
      if (exit.length === max) {
        const sum = exit.reduce((a, b) => (a + b), 0);
        const avg = sum / exit.length;
        console.log(`${timer} = ${avg}`);
        resolve(x)
      }
    }, 1000);

    redo();
  });
}

Promise.all(timer.map(crono)).then(process.exit);

And this is the output vith nodejs 8.11: that shows no difference in terms of throughput:

回答5:

The recursive function cause a stack overflow. That's not what you want.

The setInterval and setTimeout ways you have shown are identical, except that setInterval is more clear.

I'd recommend setInterval. (After all, that is what it's for.)

回答6:

//use setInterval function

setInterval(function(){Property=value;},1000);

1000ms=1second; property like style.width etc;