Как обеспечить выполнение хрон-задания точно на каждой возможной 5-минутной отметке (0:00, 0:05, 0:10) независимо от времени начала хрон-задания?

(function loop() {
  const date = new Date();
  const wait = 300000 - date % 300000
  console.info(date, wait);

  setTimeout(() => {
    console.info(new Date())

    loop();
    // your code here
  }, wait);
})();

const myFunction = () => {
  console.info("Function executed at:", new Date().toLocaleTimeString());
}

const getNearestFiveMinuteMark = () => {
  const now = new Date();
  const minutes = now.getMinutes();
  return Math.ceil(minutes / 5) * 5;
}

const initializeFiveMinuteArray = () => {
  const nearestFiveMinuteMark = getNearestFiveMinuteMark();
  const intervals = [];
  for (let i = 0; i < 12; i++) { // 12 entries for every 5 minutes in an hour
    intervals.push((nearestFiveMinuteMark + i * 5) % 60);
  }
  return intervals;
}

const checkTimeAndRunMainFunction = () => {
  const now = new Date();
  const currentMinute = now.getMinutes();

  if (currentMinute === fiveMinuteIntervals[0]) {
    // Run the main function and move the entry to the end
    myFunction();
    const executedEntry = fiveMinuteIntervals.shift();
    fiveMinuteIntervals.push(executedEntry);
  }
  time.textContent = `next run will be at :${String(fiveMinuteIntervals[0]).padStart(2,'0')}`;
}

const fiveMinuteIntervals = initializeFiveMinuteArray();
console.info("Initial 5-minute intervals array:", fiveMinuteIntervals);

// Set an interval to check the time every second
setInterval(checkTimeAndRunMainFunction, 1000);

<span id = "time"></span>

function getTimeToNextAvailableSchedulerSlot(slotPrecisionInSeconds) {
  const current = new Date;

  const precisionInMilliseconds = Number
    .isFinite(slotPrecisionInSeconds = parseInt(slotPrecisionInSeconds, 10))
      ? (slotPrecisionInSeconds * 1000)
      : 60_000; // 1 minute slot default.

  const currentMilliseconds = (
    current.getHours() * 60 * 60 * 1000 +
    current.getMinutes() * 60 * 1000 +
    current.getSeconds() * 1000 +
    current.getMilliseconds()
  );

  return (
    precisionInMilliseconds -
    (currentMilliseconds % precisionInMilliseconds)
  );
}

function scheduleTask(task, slotPrecisionInSeconds) {
  const timerIds = {
    timeout: null, interval: null,
  };
  const delay = getTimeToNextAvailableSchedulerSlot(slotPrecisionInSeconds);

  timerIds.timeout = setTimeout(() => {

    timerIds.interval = setInterval(task, slotPrecisionInSeconds * 1000);
    task();

  }, delay);

  return timerIds;
}


function chron_job_5_seconds_slot() {
  console.info('5 seconds chron job executed at ...', new Date().toLocaleTimeString());
}
function chron_job_15_seconds_slot() {
  console.info('15 seconds chron job executed at ...', new Date().toLocaleTimeString());
}
function chron_job_1_minute_slot() {
  console.info('1 minute chron job executed at ...', new Date().toLocaleTimeString());
}
function chron_job_5_minutes_slot() {
  console.info('5 minutes chron job executed at ...', new Date().toLocaleTimeString());
}
console.info('initialization started at ... ', new Date);

// execution at the next available 5 seconds slot continued with a 5 seconds interval.
const timer_ids_5_seconds_slot = scheduleTask(chron_job_5_seconds_slot, 5);

// execution at the next available 15 seconds slot continued with a 15 seconds interval.
const timer_ids_15_seconds_slot = scheduleTask(chron_job_15_seconds_slot, 15);

// execution at the next available 1 minute slot continued with a 1 minute interval.
const timer_ids_1_minute_slot = scheduleTask(chron_job_1_minute_slot, 60);

// execution at the next available 5 minutes slot continued with a 5 minutes interval.
const timer_ids_5_minutes_slot = scheduleTask(chron_job_5_minutes_slot, 5 * 60);


// terminate the 5 seconds based task immediately.
clearTimeout(timer_ids_5_seconds_slot.timeout);

// terminate all other tasks after 15 minutes.
setTimeout(() => {

  clearInterval(timer_ids_15_seconds_slot.interval);
  clearInterval(timer_ids_1_minute_slot.interval);
  clearInterval(timer_ids_5_minutes_slot.interval);

}, 15 * 60 * 1000);

.as-console-wrapper { min-height: 100%!important; top: 0; }

function loggerOne() {
  console.info(
    `\nlogger ONE executed at ... ${ new Date().toLocaleTimeString() }\n`
  );
}
function loggerTwo() {
  console.info(
    `logger TWO executed at ... ${ new Date().toLocaleTimeString() }`
  );
}


function controller(clockedData) {
  const {
    clock: { interval, startTime, timestamp, count },
    target, args, proceed, terminate,
  } =
    clockedData;

  const passedTime = timestamp - startTime;
  const passedSeconds = passedTime / 1000;

  // - implement controller logic as you like/need.

  if (count > 10) {

    terminate();

  } else {
    console.info({
      interval,
      startTime,
      timestamp,
      passedSeconds,
      count,
      target,
      args,
      proceed,
    });

    // - calling the function that needs
    //   to be executed in a clocked way.

    proceed.apply(target, args);
  }
}
const clocked_at_20_seconds_cycling_infinitely =
  loggerOne.clocked(20_000);

const clocked_at_07_seconds_limited_to_10_cycles =
  loggerTwo.clocked(7_000, null, controller);


console.info(
  `... test started at ... ${ new Date().toLocaleTimeString() }`
);
clocked_at_20_seconds_cycling_infinitely();
clocked_at_07_seconds_limited_to_10_cycles();

body { margin: 0; }
.as-console-wrapper { min-height: 100%!important; top: 0; }

<script>
(function (Reflect, Math, Number, Array, Function) {

  'use strict';

  /**
   * @typedef {Object} clockedControllerClockData
   *  @param {number} interval  - interval-value in milliseconds.
   *  @param {number} startTime - time of first invocation in milliseconds.
   *  @param {number} timestamp - time of current invocation in milliseconds.
   *  @param {number} count     - current invocation-count since first invocation; `count` value of 1st invocation is `1`.
   */

  /**
   * A data object which holds all the necessary references
   * in order to properly run any controller logic.
   *
   * @typedef {Object} clockedControllerData
   *  @param {clockedControllerClockData} clock
   *  @param {(Object|null)} target
   *  @param {Array} args
   *  @param {Function} proceed
   *  @param {Function} terminate
   */

  /**
   * A callback function which acts like a pre-processor which e.g. can decide
   * whether to proceed with or terminate the original functions `clocked` version.
   *
   * @callback clockedController
   *  @param {clockedControllerData} data
   *   A data object which holds all the necessary references
   *   in order to properly run any controller logic.
   */

  const DEFAULT_INTERVAL = 200;

  const { isFinite, parseInt } = Number;

  function isFunction(value) {
    return (
      typeof value === 'function' &&
      typeof value.call === 'function' &&
      typeof value.apply === 'function'
    );
  }

  function getSanitizedInteger(value) {
    value = parseInt(value, 10);
    return isFinite(value) ? value : 0;
  }
  function getSanitizedPositiveInteger(value) {
    return Math.max(getSanitizedInteger(value), 0);
  }

  /**
   *  Returns a function, that, invoked initially once, will continuously auto-invoke
   *  the original function every amount of milliseconds, as it was parametrized by
   *  this methods `interval` argument. It does so until the additional `terminate`
   *  method of the returned wrapper function gets called.
   *  This methods second parameter - `target` - provides the object/context a `clocked`
   *  method can act upon.
   *  This methods third parameter - `controller` - enables the even more precise
   *  customized handling of how to run a `clocked` function/method.
   *
   * @param {number=} interval  - The optional interval value; expected to be grater than zero and assuming milliseconds.
   * @param {*=} target         - The function's/method's optional target object.
   * @param {clockedController=} controller
   *  The optional callback function which acts like a pre-processor where additionally
   *  provided program logic might e.g. decide whether to proceed with or terminate
   *  the original functions `clocked` version.
   * @returns {Function}
   *  The original function's/method's `clocked` version.
   */
  function createClockedFunction(interval/*, delay*/, target, controller) {
    const proceed = this;

    let thisArg;
    let argsArr;

    let clockCount = null;
    let clockStart = null;

    let timerId = null;

    target = target ?? null; // `null` instead of an `undefined` default.
    interval = getSanitizedPositiveInteger(interval) || DEFAULT_INTERVAL;

    function triggerController() {
      controller({
        clock: {
          interval,
          startTime: clockStart,
          timestamp: Date.now(),
          count: ++clockCount,
        },
        target: thisArg,
        args: [...argsArr],
        proceed,
        terminate,
      });
    }
    function triggerProceed() {
      proceed.apply(thisArg, argsArr);
    }

    function terminate() {
      clearInterval(timerId);
      timerId = null;

      clockStart = null;
      clockCount = null;
    }

    function isActive() {
      return (timerId !== null);
    }

    function clocked(...argumentsArray) {
      // - a `clocked` method's target can be delegated at call time, thus
      //   it overrules the target which was provided at composition time.
      thisArg = (this ?? null) ?? target;
      argsArr = argumentsArray;

      if (isActive()) {
        terminate();
      }
      clockCount = 0;
      clockStart = Date.now();

      const trigger = isFunction(controller)
        ? triggerController
        : triggerProceed;

      timerId = setInterval(trigger, interval);
    }
    clocked.terminate = terminate;
    clocked.isActive = isActive;

    return (isFunction(proceed) && clocked) || proceed;
  }

  Reflect.defineProperty(Function.prototype, 'clocked', {
    configurable: true,
    writable: true,
    value: createClockedFunction,
  });

}(Reflect, Math, Number, Array, Function));
</script>