計算指定時間段內的總時長NodeJs -有解無憂

我正在計算從作業開始時間& 作業結束時間的超時時間。

我們需要計算不包括正常作業時間的超時時間。

舉個例子。常規作業時間是上午10:00至下午7:00

我們需要計算不包括常規作業時間的超時作業。

超時作業需要從這些時間段中得到。開始作業時間。13-09-2021 08:0015-09-2021 20:00

我們需要計算10:00 AM到07:00 PM之外的總時間，從開始作業時間。13-09-2021 08:00 & End Work Hour: 15-09-2021 20:00

因此，這里的總加班時間將是。32小時

我已經試過了。

我試著做了什么？

如果作業開始時間和結束時間在同一天，用下面的代碼計算加班費就可以了。

Start Hour : 15-09-21 08:00結束時間：15-09-21 21:00

。
getWorkHours.forEach((workhourOT) =>  {
            try {
        
              // --------------------------------------
              let StartWorkHour = moment(
                workhourOT.starttime。
                "DD-MM-YYY hh:mm:ss".
              );
              let TodayOfficeStartDate =
                moment(StartWorkHour).format（"DD-MM-YYY"）。

              let StartOfficeHour = moment(
                `${TodayOfficeStartDate}`   `10:00:00`。
                "DD-MM-YYY hh:mm:ss".
              );

              const diffInMillisecondsBeforeOfficeHour = Math.abs(
                new Date（StartWorkHour）- new Date(StartOfficeHour)
              );
              let OTBeforeOffice =
                diffInMillisecondsBeforeOfficeHour / 1000 / 3600。
              console.log（OTBeforeOffice）。
              let EndtWorkHour = moment(
                workhourOT.endtime,
                "DD-MM-YYY hh:mm:ss"。
              );

              let TodayOfficeEndDate =
                moment(EndtWorkHour).format（"DD-MM-YYY"）。

              let EndOfficeHour = moment(
                `${TodayOfficeEndDate}`   `19:00:00`。
                "DD-MM-YYY hh:mm:ss"。
              );

              const diffInMillisecondsAfterOfficeHour = Math.abs(
                new Date（EndtWorkHour）- new Date(EndOfficeHour)
              );
              let OTAfterOffice =
                diffInMillisecondsAfterOfficeHour / 1000 / 3600。
              console.log（OTAfterOffice）。
              let totalWORKOT = OTAfterOffice   OTBeforeOffice;

              data["TotalWork_OT"] = totalWORKOT.toFixed（1）。
            } catch (error) {
              console.log（錯誤）。
            }
          });

OutPut是

{

    "TotalWork_OT"。"4.0"。

}

uj5u.com熱心網友回復：

為了達到所需的結果，OP中缺少很多邏輯。考慮一種方法，即一個workHours物件{startTime, endTime}被增強了一個加班屬性。

對于每個workHours物件，需要處理以下情況，其中名義上的開始和結束時間是正常時間（10:00至19:00）：

開始和結束時間都在名義時間之前。
開始和結束時間在名義開始時間之前
開始和結束于名義上的開始之后
在名義時間內開始，在名義時間內結束
在名義時間內開始，在名義時間后結束
在名義時間內開始和結束
在名義時間內開始，在名義時間內結束

此外，它還需要考慮到超過午夜的時間，并且可能還需要跳過周末。

OP假設作業在額定開始時間之前開始，在額定結束時間之后結束，因此下面的例子也是如此。因此，它只解決了上述情況中的一種，并且幾乎沒有錯誤處理，但它應該提供了一個完成作業所需的概念。

它接收一個作業時間物件并回傳一個新的物件，該物件帶有一個加班屬性和范圍內的加班時間。它只處理整個小時，并且作業開始和結束時間分別是在名義開始和結束時間之前和之后。

每個輔助函式都可以通過所需的額外功能進行擴展，以處理其他情況，并處理部分時間（可能四舍五入到15分鐘的增量）。

。

// Parse timestamp in DD-MM-YYY HH:mm format
///日之后的值是可選的，默認為零（0）。
function parseWorkHour（wh） {
  let [D, M, Y, H, m, s] = wh.split(/W/) 。
  return new Date（Y, M-1, D, H||0, m||0, s||0）。)
}

//將日期格式化為DD-MM-YYY HH:mm。
function formatWorkHour（date）{
  let z = n => ('0' n).slice（-2）。
  return `${z(date. getDate())}-${z(date.getMonth() 1）}-`  
         `${date.getFullYear()} ${z(date.getHours())}：`  
         `${z(date.getMinutes())}`。
}

//如果date1和date2是同一天，回傳true。
function areSameDay(d1, d2) {
  return !isNaN(d1) && !isNaN(d2) &&
         d1.getFullYear() == d2.getFullYear() &＆amp;
         d1.getMonth() == d2.getMonth() &＆amp;
         d1.getDate() == d2.getDate()。
}

// Given workhours object {startTime, endTime} return
//為輸入物件范圍的每日作業時間物件的陣列。
function getDailyWorkHours（who）{
  let start = parseWorkHour(who.startTime) 。
  let end = parseWorkHour(who.endTime) 。
  let dailyWorkHours = [];
  //沒有驗證（例如：start > end），所以要防止無限回圈。
  let i = 10;
  
  while (!areSameDay(start, end) & & --i) {
    let temp = new Date（start）。
    temp.setHours(23,59,59，999)。
    dailyWorkHours.push（{
      startTime: formatWorkHour(start),
      endTime: formatWorkHour(temp)
    });
    temp.setHours(24,0,0)。
    start = temp;
  }
  dailyWorkHours.push（{
    startTime: formatWorkHour(start),
    endTime: formatWorkHour(end)
  });
  return dailyWorkHours;
}

//從workHours物件{startTime, endTime}中獲取加班時間。
//startTime和endTime必須是同一天。。
//加班時間為10:00之前和19:00之后。
function getOvertime（who）{
  let workStart = parseWorkHour(who.startTime) 。
  let workEnd = parseWorkHour(who.endTime) 。
  let officeStart = new Date（ workStart）。
  officeStart.setHours(10,0,0)。
  let officeEnd = new Date（ workEnd）。
  officeEnd.setHours(19,0,0) 。
  let ot = (officeStart - workStart) / 3.6e6  
           (workEnd - officeEnd) / 3.6e6。
  //四舍五入到最接近的小時。
  return Math.round（ot）。        
}

//給定作業時間陣列[{startTime,endTime}]，計算如何？
//多少加班時間， 
///即officeStart（10:00）和officeEnd（19:00）之前的時間 
function tallyOvertime(workHoursArray) {
  let result = [] 。
  
  workHoursArray.forEach( who =>  {
    let dailyWorkHours = getDailyWorkHours（who）。
    let overTime = dailyWorkHours.reduce((ot, who) =>  {
      ot  = getOvertime（who）。
      return ot。
    }, 0）。)
    result.push（{
      startTime: who.startTime,
      endTime:who.endTime。
      overTime:overTime
    });
  });
  return result。
}

let data = [
  // Same day - 5 hrs
  {startTime:'20-09-2021 06:00'/span>, endTime:'20-09-2021 20:00'/span>}。
  //over midnight - 20 
  {startTime:'20-09-2021 06:00'/span>, endTime:'21-09-2021 20:00'/span>}。
  // OP 示例 - 33 
  {startTime:'13-09-2021 08:00', endTime:'15-09-2021 20:00'}.
];

console.log(tallyOvertime(data));

在OP中，有：

我們需要計算上午10:00至下午7:00之外的總時間，從開始作業時間：13-09-2021 08:00 & 結束作業時間：15-09-2021 20:00

因此，這里的總加班時間將是。32小時

這是不正確的。細目如下：

13-09-2021年08:00至10:00為2小時
13-09-2021年19:00至24:00為5小時
14-09-2021年00:00至10:00為10個小時
14-09-2021年的19:00至24:00為5小時
15-09-2021年00:00至10:00是10小時

這總共是33個小時，而不是32個小時。

uj5u.com熱心網友回復：

我曾做過這樣的事情。 作業開始日期：18-09-21 08:00作業結束日期：20-09-21 20:00

獲得作業的加班費。
獲取作業開始日期至同一天午夜的OT。開始。18-09-21 08:00 ---- 結束。18-08-21 24:00
獲取從作業結束日期的開始日到作業結束時間的OT。開始。20-09-21 00:00 --- end: 20-09-21 20:00
在每一個全天的作業中，我們得到15小時的加班費，不包括正常的作業時間。因此，我們可以用15乘以全天的總加班費，并將所有三個結果相加。

OT函式

async function calculateWorkOverTime（TimingArr）{
  for (OTI = 0; OTI < TimingArr. length; OTI  ) {
    try {

      
      let StartWorkHour = moment(
        TimingArr[OTI].starttime。
        "DD-MM-YYY hh:mm:ss"。
      );
      let TodayOfficeStartDate = moment（StartWorkHour）。 format("DD-MM-YYY") 。

      let StartOfficeHour = moment(
        `${TodayOfficeStartDate}`   `10:00:00`。
        "DD-MM-YYY hh:mm:ss".
      );

      const diffInMillisecondsBeforeOfficeHour = Math.abs(
        new Date（StartWorkHour）- new Date(StartOfficeHour)
      );
      let OTBeforeOffice = diffInMillisecondsBeforeOfficeHour / 1000 / 3600;
      // console.log(OTBeforeOffice);
      let EndtWorkHour = moment(TimingArr[OTI] 。 endtime, "DD-MM-YYY hh:mm:ss"）。)

      let TodayOfficeEndDate = moment（EndtWorkHour）。 format("DD-MM-YYY") 。

      let EndOfficeHour = moment(
        `${TodayOfficeEndDate}`   `19:00:00`。
        "DD-MM-YYY hh:mm:ss"。
      );

      const diffInMillisecondsAfterOfficeHour = Math.abs(
        new Date（EndtWorkHour）- new Date(EndOfficeHour)
      );
      let OTAfterOffice = diffInMillisecondsAfterOfficeHour / 1000 / 3600。

      let totalWORKOT = OTAfterOffice   OTBeforeOffice;

      return totalWORKOT;
    } catch （錯誤） {
      return error;
    }
  }

var OT = ""/span>;
          for (OTArr = 0; OTArr < getWorkHours.length; OTArr  ) {
            let StartTimingWork = moment(
              getWorkHours[OTArr].starttime,
              "DD-MM-YYY hh:mm:ss"。
            );

            let TodayStartTiming = moment（StartTimingWork）。 format("DD-MM-YYY") 。

            let EndTimingWork = moment(
              getWorkHours[OTArr].endtime,
              "DD-MM-YYY hh:mm:ss"。
            );
            console.log（getWorkHours）。
            let TodayEndTiming = moment(EndTimingWork) 。 format("DD-MM-YYY") 。
            if (TodayEndTiming == TodayStartTiming) {
              let getOTFROMTIMING = await otcontroller.calculateWorkOverTime(
                計時
              );
              OT = getOTFROMTIMING;
              data["WOT"] = OT;
            } else {
              //var workstartDate = moment(TodayEndTiming, "DD-MM-YYY");
              var workstartDate = StartTimingWork;
              let currentDayMidNight = moment（workstartDate）.endOf（"day"）。
              let ArrOfTiming = [
                {
                  starttime: workstartDate,
                  endtime: currentDayMidNight,
                },
              ];

              let getOTFROMTIMING = await otcontroller.calculateWorkOverTime(
                ArrOfTiming; ArrOfTiming.
              );
              console.log（getOTFROMTIMING）。

              var workendDate = EndTimingWork。
              let startOfWorkEndDate = moment（workendDate）.startOf（"day"）。
              // console.log(workendDate);.
              // console.log(startOfWorkEndDate);.
              let ArrOfTimingEnd = [
                {
                  starttime: startOfWorkEndDate,
                  endtime: workendDate,
                },
              ];
              let getOTFROMTIMINGlastDay =
                await otcontroller.calculateWorkOverTime(ArrOfTimingEnd) 。
              console.log（getOTFROMTIMINGlastDay）。
              //var workendDate = EndTimingWork;.
              // console.log(workstartDate);
              console.log("workendDate"/span>)。
              console.log（workendDate）。
              console.log（workstartDate）。
              console.log("workstartDate"/span>)。
              var result = workendDate.diff(workstartDate, "day");
              console.log（result）。
              console.log("result"/span>)。

              let wholeDaysOT = (result - 1) * 15;
              console.log(
                wholeDaysOT   getOTFROMTIMINGlastDay   getOTFROMTIMING
              );
              let TotalWorkOverTime =
                wholeDaysOT   getOTFROMTIMINGlastDay   getOTFROMTIMING;
              data["WOT"] = TotalWorkOverTime.toFixed（1）。
            }

轉載請註明出處，本文鏈接：https://www.uj5u.com/caozuo/328890.html

標籤：

上一篇：如果一個國家改變了它的夏令時設定，TimeZoneInfo會發生什么？

下一篇：將文本時間轉換成DateTime變數c#