timers

---

1. Scheduling a Timeout

setTimeout(() => {
  console.log('Timeout');
}, 2000);

2. Scheduling a Repeating Interval

setInterval(() => {
  console.log('Interval');
}, 1000);

3. Clearing a Timeout

const timeoutId = setTimeout(() => {
  console.log('Timeout');
}, 2000);

clearTimeout(timeoutId);

4. Clearing an Interval

const intervalId = setInterval(() => {
  console.log('Interval');
}, 1000);

clearInterval(intervalId);

5. Measuring Execution Time

const startTime = Date.now();

// Code to measure...

const endTime = Date.now();
console.log(`Execution time: ${endTime - startTime} ms`);

6. Debouncing

const debouncedFunction = debounce(func, 500);

// Call the debounced function
debouncedFunction();

7. Throttling

const throttledFunction = throttle(func, 500);

// Call the throttled function
throttledFunction();

8. Animating with requestAnimationFrame

const animate = () => {
  // Animation logic...

  requestAnimationFrame(animate);
};

animate();

9. Cancelling an Animation

const animationId = requestAnimationFrame(animate);

cancelAnimationFrame(animationId);

10. Scheduling a Delayed Function

Promise.delay(1000).then(() => {
  console.log('Delay');
});

11. Scheduling a Future Function

const time = new Date('2023-05-10T10:00:00Z');
const futureFunction = () => {
  console.log('Future');
};

setTimeout(futureFunction, time - Date.now());

12. Scheduling a Repeating Function at a Specific Time

const time = new Date('2023-05-10T10:00:00Z');
const repeatFunction = () => {
  console.log('Repeat');
};

setInterval(repeatFunction, time - Date.now());

13. Scheduling a Unique Function at a Specific Time

const time = new Date('2023-05-10T10:00:00Z');
const uniqueFunction = () => {
  console.log('Unique');
};

setTimeout(() => {
  uniqueFunction();
  clearInterval(intervalId);
}, time - Date.now());

14. Scheduling a Function at a Specific Interval

const intervalFunction = () => {
  console.log('Interval');
};

setInterval(intervalFunction, 1000);

15. Scheduling a Function at a Variable Interval

let interval = 1000;
const variableIntervalFunction = () => {
  console.log('Variable Interval');
  intervalFunction();

  // Adjust interval
  interval *= 2;
};

setInterval(variableIntervalFunction, interval);

16. Scheduling a Function at a Lagging Interval

let previous = Date.now();
const laggingIntervalFunction = () => {
  const now = Date.now();
  console.log(`Lag: ${now - previous} ms`);
  previous = now;

  setTimeout(laggingIntervalFunction, 1000);
};

laggingIntervalFunction();

17. Scheduling a Function at a Constant Rate

let timer = null;
const constantRateFunction = () => {
  clearTimeout(timer);
  console.log('Constant Rate');

  timer = setTimeout(constantRateFunction, 1000);
};

constantRateFunction();

18. Scheduling a Function with Flexible Timing

const flexibleTimeout = (callback, min, max) => {
  const delay = Math.random() * (max - min) + min;
  setTimeout(callback, delay);
};

flexibleTimeout(() => {
  console.log('Flexible Timeout');
}, 1000, 2000);

19. Scheduling a Function After a Dynamic Delay

const delayAfterCalculation = (callback, time) => {
  setTimeout(() => {
    callback(time);
  }, time);
};

delayAfterCalculation((time) => {
  console.log(`Delay: ${time} ms`);
}, 2000);

20. Scheduling Multiple Functions at Once

const tasks = [
  () => { console.log('Task 1'); },
  () => { console.log('Task 2'); },
  () => { console.log('Task 3'); }
];

tasks.forEach((task) => setTimeout(task, 500));

21. Queuing Functions for Sequential Execution

const queue = [];
const executeQueue = () => {
  if (queue.length) {
    queue.shift()();
    executeQueue();
  }
};

queue.push(() => { console.log('Queue Task 1'); });
queue.push(() => { console.log('Queue Task 2'); });
queue.push(() => { console.log('Queue Task 3'); });

executeQueue();

22. Scheduling a Promise-Based Task

const promiseTimer = (time) => {
  return new Promise((resolve) => {
    setTimeout(() => { resolve() }, time);
  });
};

promiseTimer(2000).then(() => {
  console.log('Promise Timer');
});

23. Using a Cron-Style Scheduler

const cron = require('node-cron');
const task = cron.schedule('* * * * *', () => {
  console.log('Cron Task');
});

24. Using a Queue-Based Scheduler

const queuelib = require('queuelib');
const queue = queuelib.createQueue();

queue.enqueue(() => {
  console.log('Queue Task');
});

25. Simulating a Countdown

const countdown = (time) => {
  return new Promise((resolve) => {
    let remaining = time;
    const interval = setInterval(() => {
      remaining -= 100;
      console.log(`Remaining: ${remaining} ms`);
      if (remaining <= 0) {
        clearInterval(interval);
        resolve();
      }
    }, 100);
  });
};

countdown(2000).then(() => {
  console.log('Countdown Finished');
});

26. Measuring Time Between Events

let startTime, endTime;

const startTimer = () => {
  startTime = Date.now();
};

const endTimer = () => {
  endTime = Date.now();
  console.log(`Time: ${endTime - startTime} ms`);
};

27. Scheduling a Function for Multiple Timeouts

const timeouts = [100, 500, 1000];
const scheduleTimeouts = () => {
  timeouts.forEach((timeout) => setTimeout(() => {
    console.log(`Timeout: ${timeout} ms`);
  }, timeout));
};

scheduleTimeouts();

28. Scheduling a Function with Random Delays

const randomDelay = () => {
  return Math.floor(Math.random() * 1000);
};

const scheduleRandomDelay = () => {
  setTimeout(() => {
    console.log('Random Delay');
    scheduleRandomDelay();
  }, randomDelay());
};

scheduleRandomDelay();

29. Scheduling a Function with Exponential Delay

let delay = 100;
const scheduleExponentialDelay = () => {
  setTimeout(() => {
    console.log(`Exponential Delay: ${delay} ms`);
    delay *= 2;
    scheduleExponentialDelay();
  }, delay);
};

scheduleExponentialDelay();

30. Implementing a Stoppable Timer

class StoppableTimer {
  constructor(timeout, callback) {
    this.timeout = timeout;
    this.callback = callback;
    this.timerId = null;
  }

  start() {
    this.timerId = setTimeout(this.callback, this.timeout);
  }

  stop() {
    clearTimeout(this.timerId);
  }
}

31. Scheduling a Task with a Timeout and Retry

const retryTaskWithTimeout = (callback, timeout, maxRetries) => {
  let retries = 0;
  const timer = setInterval(() => {
    retries += 1;
    if (callback()) {
      clearInterval(timer);
    } else if (retries >= maxRetries) {
      clearInterval(timer);
      throw new Error('Task failed after max retries');
    }
  }, timeout);
};

32. Scheduling a Task with Periodic Progress Reports

const progressTask = (callback, interval) => {
  let progress = 0;
  const timer = setInterval(() => {
    progress = callback(progress);
    if (progress >= 1) {
      clearInterval(timer);
    }
  }, interval);
};

33. Scheduling a Task with a Dynamic Timeout

const dynamicTimeoutTask = (callback, timeoutFunction) => {
  let timer = setTimeout(callback, timeoutFunction());
  const updateTimeout = () => { timer = setTimeout(callback, timeoutFunction()); };
  return updateTimeout;
};

34. Scheduling a Task with Throttled Execution

const throttleTask = (callback, interval) => {
  let lastExecution = null;
  return () => {
    const now = Date.now();
    if (!lastExecution || now - lastExecution >= interval) {
      callback();
      lastExecution = now;
    }
  };
};

35. Scheduling a Task with Debounced Execution

const debounceTask = (callback, interval) => {
  let timer = null;
  return () => {
    clearTimeout(timer);
    timer = setTimeout(callback, interval);
  };
};

36. Scheduling a Task with a Backoff Policy

const backoffTask = (callback, initialTimeout, maxTimeout, multiplier) => {
  let timeout = initialTimeout;
  const timer = setTimeout(callback, timeout);
  const resetTimer = () => { timeout = initialTimeout; clearTimeout(timer); };
  return () => {
    clearTimeout(timer);
    if (timeout < maxTimeout) { timeout *= multiplier; }
    timer = setTimeout(callback, timeout);
    resetTimer();
  };
};