如何实现类似油门的功能，但又不会在调用之间浪费时间

Question

I would like to implement a helper function like lodash's throttle, but which calls the passed callback only if the last call ended (and if not, delays the new call until then), instead of having a rule like "one call every x milliseconds".

What's the best approach here? Thanks.

Answer 1

So What you eventually want is to queue your function calls and call them from the stack.

 // keep a stack of inputs for the function calls var stack = [], timer = null; function process() { var item = stack.shift(); // // process the item here // if (stack.length === 0) { clearInterval(timer); timer = null; } } // every time you call the function on event. instead of calling the processing function // call this to add it in a queue function queue(item) { stack.push(item); if (timer === null) { timer = setInterval(process, 500); } }

You can make this function work for multiple types of calls too. // use item as a deciding factor

 // keep a stack of inputs for the function calls var stack = [], timer = null; function reset(item){ // reset item here } function process() { var item = stack.shift(); // // process the item here // switch (item.call) { case 'reset': reset(item); break; case 'stop': // stop(item); break; default: // code block // deal with it } if (stack.length === 0) { clearInterval(timer); timer = null; } } // every time you call the function on event. instead of calling the processing function // call this to add it in a queue // for hybrid calls // use item = {'call': 'reset', 'data': item} function queue(item) { stack.push(item); if (timer === null) { timer = setInterval(process, 500); } }

Answer 2

try using boolean variable like

var running = false;

use setInterval or similar function and put condition if(!running){} for statements to be performed. if statement is going to run then make running = true .

Answer 3

Finally worked out a way :

class Scheduler {
  private readonly stack: Function[] = [];

  private enqueue(task: Function) {
    if (this.stack.length < 2) this.stack.push(task);
    else this.stack[1] = task;
  }

  private dequeue() {
    if (this.stack.length) {
      const task = this.stack.shift()!;
      task();
      defer(() => this.dequeue());
    }
  }

  run(task: Function) {
    this.enqueue(task);
    defer(() => this.dequeue());
  }
}

// Usage :

const scheduler = new Scheduler()

// Very frequent call :

scheduler.run(() => { /* your heavy task */ })