js multiple loop - time deduction [closed]

Here is my take at solving this interesting problem, unfortunately ignoring your code a bit. My instinct is to convert these timestamp strings into a parsed form so that we can sort them and work with a single array of sorted and tagged timestamps. I've written some code and it seems to work great. Of course, it's not very robust, but the point is that it would be quite easy to modify/improve. The main algorithm at play here is a simple state machine, reading the "tape" of timestamps from earliest to latest.

/**
 * Wraps time strings (XX:XX) into a more
 * digestible format.
 */
class Timestamp {

    /**
     * @param {string} notation
     * @param {"shiftStart" | "shiftEnd" | "absenceStart" | "absenceEnd"} type
     */
    constructor(notation, type) {
        if (notation.length !== 5) {
            throw new Error(`Invalid length`);
        }

        const digits = new Uint8Array(5);
        let char;
        for (let i=0; i < 5; i++) {
            char = notation.charCodeAt(i);
            if (i === 2) {
                if (char !== 0x3A) {
                    throw new Error(`Missing separator at index 2`);
                } else {
                    continue;
                }
            }
            if (char < 0x30 || char > 0x39) {
                throw new Error(`Non-digit character at index ${i}`);
            }
            digits[i] = char - 0x30;
        }

        const hour = (digits[0] * 10) + digits[1];
        const minute = (digits[3] * 10) + digits[4];
        if (hour > 23) throw new Error(`Invalid hour ${hour}`);
        if (minute > 59) throw new Error(`Invalid minute ${minute}`);

        this.notation = notation;
        this.hour = hour;
        this.minute = minute;
        this.type = type;
    }

    /**
     * An integer which uniquely identifies this timestamp,
     * used for sorting
     * @returns {number}
     */
    get data() {
        return (this.hour * 60) + this.minute;
    }

}

// Constant Data

/**
 * Type definition for time records
 * @typedef {{ startTime: string, endTime: string }} TimeRecord
 */

/**
 * The list of shifts
 * @type TimeRecord[]
 */
const SHIFTS = [
    {
        'startTime': '08:00',
        'endTime':   '10:00'
    },
    {
        'startTime': '10:30',
        'endTime':   '16:00'
    },
    {
        'startTime': '17:00',
        'endTime':   '18:00'
    },
    {
        'startTime': '19:00',
        'endTime':   '20:00'
    }
];

/**
 * The list of absences
 * @type TimeRecord[]
 */
const ABSENCES = [
    {
        'startTime': '09:00',
        'endTime':   '09:30'
    },
    {
        'startTime': '11:00',
        'endTime':   '12:30'
    },
    {
        'startTime': '17:30',
        'endTime':   '18:00'
    }
];

// The Code

/**
 * Returns an array holding all the
 * timestamps in sorted order
 * @returns {Timestamp[]}
 */
function computeTimestamps() {
    const ret = [];

    // Add the shifts
    for (let shift of SHIFTS) {
        ret.push(new Timestamp(shift.startTime, "shiftStart"));
        ret.push(new Timestamp(shift.endTime, "shiftEnd"));
    }

    // Add the absences
    for (let absence of ABSENCES) {
        ret.push(new Timestamp(absence.startTime, "absenceStart"));
        ret.push(new Timestamp(absence.endTime, "absenceEnd"));
    }

    // Sort the timestamps
    ret.sort((a, b) => a.data - b.data);

    return ret;
}

/**
 * Converts a sorted array of timestamps to
 * an array of time records, showing all
 * time spans where there is a shift
 * but not an absence.
 * @param timestamps {Timestamp[]}
 * @returns {TimeRecord[]}
 */
function convertTimestamps(timestamps) {
    let shiftStart;
    let inShift = false;
    let inAbsence = false;
    const ret = [];

    function submit(time) {
        ret.push({
            startTime: shiftStart.notation,
            endTime: time.notation,
        });
    }

    for (let time of timestamps) {
        switch (time.type) {
            case "shiftStart":
                shiftStart = time;
                inShift = true;
                break;
            case "shiftEnd":
                if (!inShift) throw new Error("Shift end without matching start");
                if (!inAbsence) submit(time);
                inShift = false;
                break;
            case "absenceStart":
                if (inShift) submit(time);
                inAbsence = true;
                break;
            case "absenceEnd":
                if (!inAbsence) throw new Error("Absence end without matching start");
                shiftStart = time;
                inAbsence = false;
                break;
        }
    }

    return ret;
}

/**
 * Main function
 */
function main() {
    const timestamps = computeTimestamps();
    const records = convertTimestamps(timestamps);
    console.log(records);
}

main();

Output

An exact match to your desired output.

[
  { startTime: '08:00', endTime: '09:00' },
  { startTime: '09:30', endTime: '10:00' },
  { startTime: '10:30', endTime: '11:00' },
  { startTime: '12:30', endTime: '16:00' },
  { startTime: '17:00', endTime: '17:30' },
  { startTime: '19:00', endTime: '20:00' }
]