AI solution for JavaScript Coding Question on BFE.dev
84. create a fake timer (setInterval)

Solution:

To implement a fake timer with accurate timing, we need to keep track of the current time and the scheduled functions. We can use an object to store the scheduled functions with their next execution time as the key.

When setInterval is called, we calculate the next execution time by adding the delay to the current time, and store the function with the next execution time in the scheduled functions object.

When clearInterval is called, we remove the function from the scheduled functions object.

In the tick method, we go through all the functions in the scheduled functions object and execute them if their next execution time is less than or equal to the current time. We then update their next execution time by adding the delay to the current time.

Finally, we need to replace the Date.now() function with our own implementation that returns the current time. We can store the current time in a variable and update it in the tick method.

Here's the implementation:

class FakeTimer {
  constructor() {
    this.current = 0;
    this.scheduled = {};
    this.originals = {};
  }

  install() {
    // replace window.setInterval, window.clearInterval, Date.now
    this.originals.setInterval = window.setInterval;
    this.originals.clearInterval = window.clearInterval;
    this.originals.now = Date.now;

    window.setInterval = this.fakeSetInterval.bind(this);
    window.clearInterval = this.fakeClearInterval.bind(this);
    Date.now = this.fakeNow.bind(this);
  }

  uninstall() {
    // restore the original implementation of
    // window.setInterval, window.clearInterval, Date.now
    window.setInterval = this.originals.setInterval;
    window.clearInterval = this.originals.clearInterval;
    Date.now = this.originals.now;
  }

  tick() {
    // run the scheduled functions without waiting
    const scheduled = this.scheduled;
    const now = this.current;
    this.current += 1;
    Object.keys(scheduled).forEach(key => {
      if (scheduled[key] <= now) {
        const fn = scheduled[key];
        fn();
        scheduled[key] = now + Number(key);
      }
    })
  }

  fakeSetInterval(func, delay, ...args) {
    const next = this.current + delay;
    this.scheduled[delay] = () => {
      func(...args);
      this.scheduled[delay] = () => {
        func(...args);
        this.scheduled[delay] = next;
      };
    };
    return delay;
  }

  fakeClearInterval(id) {
    delete this.scheduled[id];
  }

  fakeNow() {
    return this.current;
  }
}

In the fakeSetInterval method, we first calculate the next execution time next by adding the delay to the current time. We then store the function with the delay as the key and a wrapper function that will execute the function and update the scheduled functions object with the next execution time.

When the wrapper function is called for the first time, it executes the function and sets the wrapper function to execute the function again at the same delay. This ensures that the function is executed every delay milliseconds.

When the wrapper function is called subsequently, it executes the function and then sets the scheduled function to execute the function again at the next calculated execution time.

In the fakeClearInterval method, we simply remove the scheduled function with the given id from the scheduled functions object.

In the fakeNow method, we simply return the current time stored in the current variable.

In the tick method, we go through all the scheduled functions and execute them if their next execution time is less than or equal to the current time. We then update their next execution time by adding the delay to the current time.

When we run the test code from the problem statement, it should output [100, 200] to indicate that the functions were executed at the expected times.